samualtnorman / hackmud-script-manager

Script manager for game hackmud, with minification, TypeScript support, and player script type definition generation.

Hackmud Script Manager

Command made for Hackmud Scripting Environment, which is a scripting environment for hackmud with minification, autocompletes / intellisense, and TypeScript support.

You can read about how HSM works in my blog post.

Install

1. Install Node.js
2. Run npm install -g hackmud-script-manager

Usage

1. Run #dir in game, then cd to that folder
2. Name your source script file to <name>.src.js
3. Run hsm golf <name>.src.js and it will create a minified script file called <name>.js

NOTE: If you get an error message that looks like this:

[...]\AppData\Local\pnpm\hsm.ps1 cannot be loaded because running scripts is disabled on this system. [...]

You will need to run Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope CurrentUser in PowerShell as an administrator. For more information, see Microsoft's page about Execution Policies.

Features

• Minification
  • This includes auto quine cheating.
    • Supported types are null, numbers, strings, and JSON compatible objects and arrays.
    • Non JSON compatible object keys are quine cheated.
    • Member expressions are converted to index notation so the index string can be quine cheated.
    • And template literals are converted to string concatenation so the strings can be quine cheated.
  • Global variable aliasing.
  • Convert function declarations to arrow function assigned to variable hoisted to the top of the block (function foo() { ... } -> let foo = () => ...).
  • Convert _START and _TIMEOUT to _ST and _TO.
  • Remove unused parameters from the main function expression.
• Modern Javascript Syntax and Features
  • Exponentiation Operator, Object Rest Spread, Optional Catch Binding, JSON strings, Nullish Coalescing Operator, Optional Chaining, Logical Assignment Operators, Numeric Seperators, Class Properties, Class Static Block, Private Property in Object.
  • Bigint literals are converted to BigInt() calls.
  • Hackmud already supports all modern regular expression features.
• Future JavaScript Syntax and Features
  • Warning: TypeScript doesn't support any of these features and these features may change or not actually make it into JavaScript.
  • Decorators, Do Expressions, Function Bind, Function Sent, Partial Application, Pipeline Operator (using the hack proposal and % as the topic token), Throw Expression, Record and Tuple (hash # syntax type).
• TypeScript Support
  • This command/module does not do type checking, it simply removes type annotations so you'll need to rely on your IDE or run tsc seperatly with noEmit.
• And “Cool” Unnecessary Features.
  • Variables declared outside the main function expression automatically become #G global variables.
  • Any code outside the function expression will only run once per top level script execution (#FMCL).
  • Basic seclevel verification.
    • Declaring // @seclevel HIGHSEC or any other seclevel before all of your code stops you from accidentally using #ls. or #ns..
  • Import node_modules modules into your script using import { foo } from "bar" syntax.
  • _SOURCE is replaced with a string of the source code of the script it's in.
  • _BUILD_DATE is replaced with a unix timestamp (Date.now()) of the build date of the script.
  • _SCRIPT_USER is replaced with a string of the user the script was pushed to.
    • This saves characters compared to context.this_script.split(".")[0].
  • _SCRIPT_NAME is like _SCRIPT_USER but for the name of the script.
    • Saves characters compared to context.this_script.split(".")[1].
  • _FULL_SCRIPT_NAME is replaced with what would be context.this_script.
  • #s. can be used and it'll automatically have the seclevel inserted.
  • Subscript and #db methods names are verified.
  • All references to preprocessor syntax functions not being called are turned into arrow function wrappers e.g. let debug = #D; -> let debug = v => #D(v);.
  • _SECLEVEL is replaced with a number (0 to 4) representing the seclevel of the script.
  • When exports are present in the script, it becomes a script that returns an object of the exported values.
    • _EXPORTS becomes an array of the names of the exported values.
• And Neat Weird Fixes
  • Like .__proto__ and .prototype being converted to ["__proto__"] and ["prototype"].
  • Illegal and unsafe strings.
    • Appearences of _SC and friends are either renamed or have an escape inserted so that script is legal.
    • Preprocessor syntax in strings are escaped so hackmud doesn't recognise them as preprocessor syntax.
    • And appearences of // in strings and regexes have a backslash inserted between to stop hackmud's overagressive comment remover from removing half the line of code.
  • Classes are actually usable now, this module replaces instances of this with a variable referencing what would be this.
  • Function.prototype can be referenced (but only the .prototype property, nothing else).
  • Object.getPrototypeOf and Object.setPrototypeOf are replaced with equivalent functions.

hackmud-script-manager's Issues

"Could not find any scripts to push" when not ran `user <user>` in hackmud yet

I just got caught out by this. I was confused because I definitely did have scripts to push (only global ones though)

player type generator omit WildFullsec properties to replace scripts

I'm just going through my to-do list app so this one might be out of date

Nested string arrays disappear when minified

Not sure if related to #146.
Only happens when the strings are long enough to justify quine cheat.

Input (nested declaration):

export default function (context: Context, args: { row: number }) {
	const data = [
		["aaaaaaaaaa", "bbbbbbbbbb", "cccccccccc"],
		["dddddddddd", "eeeeeeeeee", "ffffffffff"],
		["gggggggggg", "hhhhhhhhhh", "iiiiiiiiii"],
	];
	return data[args.row];
}

Output (nested declaration):

function($,e){
//	[[],"row"]	
let[t,c]=JSON.parse(#fs.scripts.quine().split`	`[1])
return t[e[c]]}

Input (flat declaration):

export default function (context: Context, args: { row: number }) {
	const row1 = ["aaaaaaaaaa", "bbbbbbbbbb", "cccccccccc"],
		row2 = ["dddddddddd", "eeeeeeeeee", "ffffffffff"],
		row3 = ["gggggggggg", "hhhhhhhhhh", "iiiiiiiiii"];
	const data = [row1, row2, row3];
	return data[args.row];
}

Output (flat declaration):

function($,s){
//	[["aaaaaaaaaa","bbbbbbbbbb","cccccccccc"],["dddddddddd","eeeeeeeeee","ffffffffff"],["gggggggggg","hhhhhhhhhh","iiiiiiiiii"],"row"]	
let[t,c,e,i]=JSON.parse(#fs.scripts.quine().split`	`[1])
return[t,c,e][s[i]]}

dummy error script

when the script can't be created due to an error
rather than creating an empty script, create a script that prints the error

Strange behaviour using functions

If I do this

export default (_context: Context, args: unknown) => { 
    $db.us(
        {
            _id: 'harvest'
        },
        {
            _id: 'harvest',
            filter: ['.pub', '.entry'],
            blacklist: ['accenture',
                'arino',
                'blackcore',
                'blackstar',
                'dynamo_corp',
                'jinteki_corp',
                'l4sh',
                'lunar_systems',
                'n_inc',
                'onion',
                'perimeter_systems',
                'ploogle',
                'pwnhub',
                'reinit',
                'rozas',
            ],
            commandRegex: 'with ([a-z`$]+):"([a-z]+)',
            userRegex: '([a-z0-9_]+) (of project|when being)',
            projectRegex: '(date for|continues on|of the|developments on|of project|review of).([a-z0-9.`_]+)',
            passwordRegex: 'strategy.([a-z0-9_]+)'
        }
    )
}

i get down to 74 chars.

If I do this

export default (_context: Context, args: unknown) => { 
    i();
}
function i() {
    $db.us(
        {
            _id: 'harvest'
        },
        {
            _id: 'harvest',
            filter: ['.pub', '.entry'],
            blacklist: ['accenture',
                'arino',
                'blackcore',
                'blackstar',
                'dynamo_corp',
                'jinteki_corp',
                'l4sh',
                'lunar_systems',
                'n_inc',
                'onion',
                'perimeter_systems',
                'ploogle',
                'pwnhub',
                'reinit',
                'rozas',
            ],
            commandRegex: 'with ([a-z`$]+):"([a-z]+)',
            userRegex: '([a-z0-9_]+) (of project|when being)',
            projectRegex: '(date for|continues on|of the|developments on|of project|review of).([a-z0-9.`_]+)',
            passwordRegex: 'strategy.([a-z0-9_]+)'
        }
    )
}

I get 208 chars.

code splitting

`--force-quine-cheats` flag

object/array inside functons/loops can be quine cheated

export default () => () => [[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]

currently becomes

function(){return()=>[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]}

an 86 char script which does not use quine cheating to preserve js semantics of getting a new instance every time the expression is evaluated. but it could become

function(){
//	["parse","[[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[],[]]"]	
let[s,t]=JSON.parse(#fs.scripts.quine().split`	`[1])
return()=>JSON[s](t)}

which is only 83 chars by using quine cheating but using JSON.parse() on a quine cheated string to preserve js semantics shaving off a whole 3 chars in this case

throws error when `hackmudPath` does not exist

not a big priority, so will fix this for 0.21 probably

show message instead of throwing when can't find hackmud folder

Couldn't find your hackmud folder. If your hackmud folder is not in the standard
place you can set its path with the environment variable HSM_HACKMUD_PATH or the
--hackmud-path=<path> option.

convert `console.log()` and friends to `#D()`

quine cheating a script that's already under 500 chars seems not very useful

replace `"UNKNOWN"`s with something better

• _SCRIPT_USER
• _SCRIPT_NAME
• _FULL_SCRIPT_NAME

use `fs.promises` instead of using `util.promisify` on callback based async functions from `fs`

so it might turn out that although there is no module fs/promises, node 12 does have a promises export from fs
woops

test does not detect syntax errors

test function is currently very primitive and just calls processScript and catches errors

`// @no-push` to stop a module being pushed as a script

convert `_START` to `_ST`

this can be done in that loop that iterates through the tokens backwards

simplify config set subcommand to only take 2 inputs

dot separated key

`pushed <script> to ...` messages aren't `S` coloured

not capitalised either

investigate why declaring seperate function and then doing `export default (context, args) => $(context, args)` reduces chars

here's an example of a script making use of this trick
https://github.com/samualtnorman/binmat/blob/main/game-scripts/binmat.ts

write a README

it's not worth quine cheating boolean literals, is it?

over aggressive object and array quine cheating

a non quine cheated version of

function () {
	return { foo: "bar" }
}

will return a new object every call

however the quine cheated version will return the same object every call per top level script execution

treat `import {} from "/foo"` as importing relative to the directory hsm is ran from

this will let people have setups that look like

src/
  my-user/
    local_script.ts
  global_script.ts
utils/
  shared-module.ts
package.json
README.md

empty object/array literal cause parent object/array literal not to be quine cheateable

the whole object in

function() {
        return { foo: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", bar: {} }
}

should be quine cheatable but instead it becomes

function(){
//      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
return{foo:#fs.scripts.quine().split`   `[1],bar:{}}}

Make 0.20 Release

• #137
• #146
• #150
• #151
• #152
• samualtnorman/hackmud-environment#27
• #155

right before release

1. update dependencies of and push to @samual/rollup-config
2. update dependencies of @samual/lib
   • update to @samual/rollup-config@dev
3. make a release of @samual/lib
4. update dependencies of @samual/rollup-config (again)
5. make a release @samual/rollup-config
6. update pnpm version using
7. update dependencies

after release

• push changes to template

dependency flattening

quine cheat comment is interpreted by hackmud as autocomplete comment

the brackets around function expressions are probably unnecessary

Support for autocompletion

Does HSM support autocompletion like
export default (_context: Context, args: Arguments) => { // t:[#s.]

unnecessary comma expressions

golfing an already quine-cheated script can break it

function () {
	//[1,2,3]
	return #fs.scripts.quine().split("\n")[1].slice(2)
}

Destructured `args` parameter name gets wrongfully minified into a comment

Initial script:

function (
  _,
  { really_long_parameter_name_that_should_not_be_minified_into_a_comment },
) {
  return really_long_parameter_name_that_should_not_be_minified_into_a_comment;
}

Command used:

npx hsm golf test.js /dev/stdout

Minified:

function($,{[e]:t}){
//	really_long_parameter_name_that_should_not_be_minified_into_a_comment	
let e=#fs.scripts.quine().split`	`[1]
return t}

The generated code fails to execute, because e is referenced before its creation.

hsm watch src doesn't watch the files in src's subfolder(user)

Since hsm push src work.
I've tried change chokidar watch option [depth] to 2, but still not working.
Great responsitory of Hackmud BTW!

alternate script format not being converted when type declarations before script

I have a feeling this one is old too

you should be able set a fallback for when `hackmudPath` isn't set

it should be passed via an environment variable or command option or something

alias function definitions to variables so terser can mangle their names

like as in turn

let someFunctionWithALongName = () => {
	// do some stuff
}

someFunctionWithALongName()
someFunctionWithALongName()

into

let someFunctionWithALongName = () => {
	// do some stuff
}

let _00000000000_LOCAL_FUNCTION_ALIAS_someFunctionWithALongName_ = someFunctionWithALongName

_00000000000_LOCAL_FUNCTION_ALIAS_someFunctionWithALongName_()
_00000000000_LOCAL_FUNCTION_ALIAS_someFunctionWithALongName_()

and then hand it off to terser.

terser currently has a bug that will cause the name of someFunctionWithALongName() to be clobbered if I do the above transformation.
I will wait for terser to amend this.

$s. does not get transformed to correct scriptspace

When I use $s. to call scripts, it gets transformed to #fs. in the result js file, even if the called script has another seclevel. This example can be used to reproduce it:

// @seclevel MIDSEC
export default (_context: Context, args: unknown) => {
    $s.chats.join({channel:""});
}

It results in
function(){#fs.chats.join({channel:""})}
despite chat.join is midsec.
Omiting // @seclevel MIDSEC does not change the result.

need to do something about `JSON.stringify()` and `JSON.parse()`

external libraries are gonna expect JSON.stringify() and JSON.parse() to have the normal not insane api

`--prettify` flag

Do not push javascript version of script if typescript version exists

Example you have tree:

• game-scripts/
  • binmat.ts
  • binmat_lib.ts
  • binmat.js
  • binmat_lib.js

Only the .ts files should be pushed.

complain about unrecognised options

currently you can typo or misremember the name of an option and not notice. detecting and erroring on unrecognised options will make this obvious.
currently this will require a rework of how command parsing works

`hsm push` (all-scripts invocation) does not follow symbolic links

If you have a script symlinked to a different location, you can push it on its own explicitly, i.e.:

hsm push src myuser.symlinked_script

but if you run the global push

hsm push

any symlinked scripts are not discovered.

not using quine cheated version in weird case

export default args => args.foo(`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`)

quine cheats to 98 chars

function(a){return a.foo("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")}

but

export default args => args.foo(`aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`)

quine cheats to 77 chars

function(o){
//	["foo","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]	
let[$,n]=JSON.parse(#fs.scripts.quine().split`	`[1])
return o[$](n)}

despite the source being longer

infer autocompletes if script has a default for `args`

function (context, args = { foo: "bar" }) {
	// ...
}

could infer // foo: "bar"

`Object` in `Object.call.bind` can be made something shorter when available

`--no-quine-cheats` flag

clean command

just delete all scripts in hackmud directory

maybe a smart version that checks the src folder first and only deletes scripts that don't have a source file

it should probably ignore `.d.ts` files

`hsm retire-user` command