@usestatemachines/cli 0.0.0-stage → 0.1.0

package/dist/generated/retry.d.ts

@@ -0,0 +1 @@
+export declare const retryPolicy: { readonly initialInterval: number; readonly maxInterval: number; readonly exponent: number; readonly statusCodes: readonly number[]; readonly retryConnectionErrors: boolean };

package/dist/generated/retry.js

@@ -0,0 +1,11 @@
+export const retryPolicy = {
+  "initialInterval": 1000,
+  "maxInterval": 5000,
+  "exponent": 1.5,
+  "statusCodes": [
+    502,
+    503,
+    504
+  ],
+  "retryConnectionErrors": true
+};

package/dist/help.d.ts

@@ -0,0 +1,408 @@
+import { z } from 'zod';
+import { type CommandHelp, type RegisteredCommand } from './command.js';
+export declare const versionSchema: z.ZodObject<{
+    cli: z.ZodString;
+    sdk: z.ZodString;
+    node: z.ZodString;
+}, z.core.$strict>;
+export declare const utilityCommands: readonly CommandHelp[];
+export declare function helpDocument(commands: readonly RegisteredCommand[], command: CommandHelp | null, group: string | null): {
+    commands: CommandHelp[];
+    globalFlags: ({
+        name: string;
+        key: string;
+        type: "string";
+        description: string;
+        short?: undefined;
+        negatedName?: undefined;
+    } | {
+        name: string;
+        key: string;
+        type: "boolean";
+        negatedName: null;
+        description: string;
+        short?: undefined;
+    } | {
+        name: string;
+        key: string;
+        short: string;
+        type: "boolean";
+        negatedName: null;
+        description: string;
+    })[];
+    exitCodes: ({
+        code: 0;
+        meaning: string;
+    } | {
+        code: 1;
+        meaning: string;
+    } | {
+        code: 2;
+        meaning: string;
+    } | {
+        code: 3;
+        meaning: string;
+    } | {
+        code: 130;
+        meaning: string;
+    })[];
+    errors: ({
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 3;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 2;
+        retryable: false;
+        userActionRequired: true;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 2;
+        retryable: false;
+        userActionRequired: true;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: true;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 3;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 3;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 3;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 3;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 3;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 2;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 2;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 2;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 3;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: true;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 2;
+        retryable: false;
+        userActionRequired: true;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 2;
+        retryable: false;
+        userActionRequired: false;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 2;
+        retryable: false;
+        userActionRequired: false;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: true;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 2;
+        retryable: false;
+        userActionRequired: true;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: true;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: true;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: true;
+        userActionRequired: true;
+        next: {
+            command: string;
+            reason: string;
+        }[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: true;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: true;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 130;
+        retryable: false;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    } | {
+        message: string;
+        exitCode: 1;
+        retryable: false;
+        userActionRequired: false;
+        next: never[];
+        code: string;
+    })[];
+};
+export declare function helpText(commands: readonly RegisteredCommand[], command: CommandHelp | null, group: string | null): string;
+export declare function completionScript(commands: readonly RegisteredCommand[], shell: 'bash' | 'zsh' | 'fish'): string;

package/dist/help.js

@@ -0,0 +1,220 @@
+import { z } from 'zod';
+import { commandHelp, } from './command.js';
+import { errorHelp, exitCodeHelp } from './errors.js';
+import { globalFlags } from './flags.js';
+export const versionSchema = z.strictObject({
+    cli: z.string(),
+    sdk: z.string(),
+    node: z.string(),
+});
+function utilityHelp(name, summary, schemas, raw = {}) {
+    return commandHelp({
+        name: [name],
+        summary,
+        need: 'public',
+        destructive: false,
+        confirmation: 'before-run',
+        streams: false,
+        acceptsWorkspace: false,
+        output: 'structured',
+        outputException: null,
+        arguments: [],
+        flags: [],
+        exitCodes: exitCodeHelp.map((entry) => entry.code),
+        ...raw,
+    }, {
+        input: schemas.input ??
+            (() => ({
+                type: 'object',
+                additionalProperties: false,
+                properties: {},
+            })),
+        result: schemas.result,
+        progress: () => false,
+    });
+}
+export const utilityCommands = [
+    utilityHelp('run', 'Run a command with a workspace key. Child streams, exit codes, and signals pass through unchanged. Use run -- <command> [args].', {
+        result: () => null,
+        input: () => ({
+            type: 'object',
+            required: ['command'],
+            properties: {
+                command: { type: 'string', minLength: 1 },
+                args: { type: 'array', items: { type: 'string' } },
+            },
+            additionalProperties: false,
+        }),
+    }, {
+        need: 'workspace',
+        acceptsWorkspace: true,
+        output: 'passthrough',
+        arguments: [
+            { name: 'command', key: 'command', required: true, many: false },
+            { name: 'args', key: 'args', required: false, many: true },
+        ],
+    }),
+    utilityHelp('help', 'Show commands, flags, result schemas, and errors.', {
+        result: () => z.json().parse(z.toJSONSchema(z.json())),
+    }),
+    utilityHelp('version', 'Show the CLI, SDK, and Node versions.', {
+        result: () => z.json().parse(z.toJSONSchema(versionSchema)),
+    }),
+    utilityHelp('completion', 'Print a shell completion script.', {
+        result: () => null,
+        input: () => z
+            .json()
+            .parse(z.toJSONSchema(z.strictObject({ shell: z.enum(['bash', 'zsh', 'fish']) }))),
+    }, {
+        output: 'raw',
+        arguments: [{ name: 'shell', key: 'shell', required: true, many: false }],
+    }),
+];
+function listed(commands, group) {
+    return [...commands.map((entry) => entry.help), ...utilityCommands].filter((entry) => group === null || entry.name[0] === group);
+}
+export function helpDocument(commands, command, group) {
+    return {
+        commands: command === null ? listed(commands, group) : [command],
+        globalFlags,
+        exitCodes: exitCodeHelp,
+        errors: errorHelp(),
+    };
+}
+function acceptedFlags(command) {
+    return [
+        ...command.flags,
+        ...globalFlags.filter((flag) => (flag.name !== 'workspace' || command.acceptsWorkspace) &&
+            (flag.name !== 'stream' || command.streams)),
+    ];
+}
+export function helpText(commands, command, group) {
+    if (command === null) {
+        const prefix = group === null ? '' : `${group} `;
+        return [
+            `Usage: statemachines ${prefix}<command> [options]`,
+            '',
+            'Commands:',
+            ...listed(commands, group).map((entry) => `  ${entry.name.join(' ')}  ${entry.summary}`),
+            '',
+            `Run statemachines ${prefix}<command> --help for arguments and options.`,
+        ].join('\n');
+    }
+    const args = command.arguments
+        .map((arg) => `${arg.required ? '<' : '['}${arg.name}${arg.many ? '...' : ''}${arg.required ? '>' : ']'}`)
+        .join(' ');
+    const flags = acceptedFlags(command);
+    return [
+        `Usage: statemachines ${command.name.join(' ')}${args === '' ? '' : ` ${args}`} [options]`,
+        '',
+        command.summary,
+        '',
+        'Options:',
+        ...flags.map((flag) => `  --${flag.name}${flag.type === 'boolean' ? (flag.negatedName === null ? '' : ` / --${flag.negatedName}`) : ' <value>'}  ${flag.description}`),
+    ].join('\n');
+}
+function completionCases(commands) {
+    const entries = listed(commands, null);
+    const groups = new Map();
+    for (const { name } of entries) {
+        const [first, second] = name;
+        groups.set(first, [
+            ...(groups.get(first) ?? []),
+            ...(second === undefined ? [] : [second]),
+        ]);
+    }
+    return [
+        { path: '', exact: true, words: [...groups.keys()] },
+        ...[...groups]
+            .filter(([, subcommands]) => subcommands.length > 0)
+            .map(([group, subcommands]) => ({
+            path: group,
+            exact: true,
+            words: subcommands,
+        })),
+        ...entries.map((entry) => ({
+            path: entry.name.join(' '),
+            exact: false,
+            words: acceptedFlags(entry).flatMap((flag) => (flag.type === 'boolean' && flag.negatedName !== null
+                ? [flag.name, flag.negatedName]
+                : [flag.name]).map((name) => `--${name}`)),
+        })),
+    ];
+}
+export function completionScript(commands, shell) {
+    const cases = completionCases(commands);
+    const pattern = ({ path, exact }) => exact ? `'${path}'` : `'${path}'|'${path} '*`;
+    const valued = globalFlags
+        .filter((flag) => flag.type !== 'boolean')
+        .map((flag) => `--${flag.name}`);
+    const booleans = globalFlags.flatMap((flag) => flag.type === 'boolean'
+        ? [`--${flag.name}`, ...('short' in flag ? [`-${flag.short}`] : [])]
+        : []);
+    const alone = [...booleans, ...valued.map((name) => `${name}=*`)];
+    switch (shell) {
+        case 'bash':
+            return [
+                '_statemachines() {',
+                "  local cur=\"${COMP_WORDS[COMP_CWORD]}\" line='' words='' skip='' word i",
+                '  for ((i = 1; i < COMP_CWORD; i++)); do',
+                '    word="${COMP_WORDS[i]}"',
+                '    if [ -n "$skip" ]; then skip=\'\'; continue; fi',
+                '    case "$word" in',
+                `      ${valued.join('|')}) skip=1 ;;`,
+                `      ${alone.join('|')}) ;;`,
+                '      *) line="${line:+$line }$word" ;;',
+                '    esac',
+                '  done',
+                '  case "$line" in',
+                ...cases.map((entry) => `    ${pattern(entry)}) words='${entry.words.join(' ')}' ;;`),
+                '  esac',
+                '  COMPREPLY=($(compgen -W "$words" -- "$cur"))',
+                '}',
+                'complete -F _statemachines statemachines',
+            ].join('\n');
+        case 'zsh':
+            return [
+                '#compdef statemachines',
+                '_statemachines() {',
+                '  local -a candidates',
+                "  local line='' skip='' word",
+                '  for word in "${(@)words[2,CURRENT-1]}"; do',
+                "    if [[ -n $skip ]]; then skip=''; continue; fi",
+                '    case "$word" in',
+                `      (${valued.join('|')}) skip=1 ;;`,
+                `      (${alone.join('|')}) ;;`,
+                '      (*) line="${line:+$line }$word" ;;',
+                '    esac',
+                '  done',
+                '  case "$line" in',
+                ...cases.map((entry) => `    ${pattern(entry)}) candidates=(${entry.words.join(' ')}) ;;`),
+                '  esac',
+                '  compadd -- "${candidates[@]}"',
+                '}',
+                'if [ "$funcstack[1]" = _statemachines ]; then',
+                '  _statemachines "$@"',
+                'else',
+                '  compdef _statemachines statemachines',
+                'fi',
+            ].join('\n');
+        case 'fish':
+            return [
+                'function __statemachines_path',
+                '  set -l words',
+                '  set -l skip',
+                '  for word in (commandline -opc)[2..-1]',
+                '    if set -q skip[1]; set -e skip; continue; end',
+                `    if contains -- $word ${valued.join(' ')}`,
+                '      set skip 1',
+                `    else if not contains -- $word ${booleans.join(' ')}; and not string match -qr -- '^(${valued.join('|')})=' $word`,
+                '      set -a words $word',
+                '    end',
+                '  end',
+                "  set -l path (string join ' ' -- $words)",
+                '  test "$path" = "$argv[1]"; or begin; test "$argv[2]" = prefix; and string match -q -- "$argv[1] *" "$path"; end',
+                'end',
+                'complete -c statemachines -f',
+                ...cases.map((entry) => `complete -c statemachines -n '__statemachines_path "${entry.path}"${entry.exact ? '' : ' prefix'}' -a '${entry.words.join(' ')}'`),
+            ].join('\n');
+    }
+}