goke 6.3.2 → 6.4.0

package/dist/goke.js

@@ -9,10 +9,11 @@
  * - createConsole: factory for console-like objects from output streams
  * - Utility functions: string helpers, bracket parsing, dot-prop access
  */
-import { EventEmitter } from 'events';
 import pc from 'picocolors';
 import mri from "./mri.js";
 import { GokeError, coerceBySchema, extractJsonSchema, extractSchemaMetadata, isStandardSchema } from "./coerce.js";
+import { createJustBashCommand as createJustBashCommandBridge } from './just-bash.js';
+import { EventEmitter, openInBrowser, process } from '#runtime';
 // ─── Node.js platform constants ───
 const processArgs = process.argv;
 const platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
@@ -238,6 +239,9 @@ class Option {
             this.isBoolean = true;
         }
     }
+    clone() {
+        return new Option(this.rawName, this.schema ?? this.description);
+    }
 }
 class Command {
     rawName;
@@ -551,6 +555,29 @@ class GlobalCommand extends Command {
         super('@@global@@', '', {}, cli);
     }
 }
+const cloneCommandInto = (source, cli) => {
+    const target = source instanceof GlobalCommand
+        ? new GlobalCommand(cli)
+        : new Command(source.rawName, source.description, { ...source.config }, cli);
+    target.aliasNames = [...source.aliasNames];
+    target.usageText = source.usageText;
+    target.versionNumber = source.versionNumber;
+    target.examples = [...source.examples];
+    target.helpCallback = source.helpCallback;
+    target.commandAction = source.commandAction;
+    target._hidden = source._hidden;
+    target.options = source.options.map((option) => option.clone());
+    target.globalCommand = cli.globalCommand;
+    return target;
+};
+class GokeProcessExit extends Error {
+    code;
+    constructor(code) {
+        super(`process.exit(${code})`);
+        this.name = 'GokeProcessExit';
+        this.code = code;
+    }
+}
 /**
  * Creates a console-like object that writes to the given output streams.
  *
@@ -566,6 +593,12 @@ function createConsole(stdout, stderr) {
         error(...args) {
             stderr.write(args.map(String).join(' ') + '\n');
         },
+        warn(...args) {
+            stderr.write(args.map(String).join(' ') + '\n');
+        },
+        info(...args) {
+            stdout.write(args.map(String).join(' ') + '\n');
+        },
     };
 }
 // ─── Error formatting ───
@@ -641,6 +674,46 @@ class Goke extends EventEmitter {
         this.globalCommand = new GlobalCommand(this);
         this.globalCommand.usage('<command> [options]');
     }
+    clone(options) {
+        const cloned = new Goke(this.name, {
+            stdout: options?.stdout ?? this.stdout,
+            stderr: options?.stderr ?? this.stderr,
+            argv: options?.argv ?? this.#defaultArgv,
+            columns: options?.columns ?? this.columns,
+            exit: options?.exit ?? this.exit,
+        });
+        cloned.showHelpOnExit = this.showHelpOnExit;
+        cloned.showVersionOnExit = this.showVersionOnExit;
+        cloned.globalCommand = cloneCommandInto(this.globalCommand, cloned);
+        cloned.commands = this.commands.map((command) => cloneCommandInto(command, cloned));
+        for (const command of cloned.commands) {
+            command.globalCommand = cloned.globalCommand;
+        }
+        cloned.middlewares = this.middlewares.map((middleware) => ({ action: middleware.action }));
+        for (const eventName of this.eventNames()) {
+            for (const listener of this.listeners(eventName)) {
+                cloned.on(eventName, listener);
+            }
+        }
+        return cloned;
+    }
+    createExecutionContext(argv = this.rawArgs) {
+        return {
+            console: this.console,
+            process: {
+                argv,
+                stdout: this.stdout,
+                stderr: this.stderr,
+                exit: (code) => {
+                    this.exit(code);
+                    throw new GokeProcessExit(code);
+                },
+            },
+        };
+    }
+    async createJustBashCommand(options) {
+        return createJustBashCommandBridge(this, options);
+    }
     /**
      * Add a global usage text.
      *
@@ -671,15 +744,16 @@ class Goke extends EventEmitter {
      * options (e.g. setting up logging, initializing state).
      *
      * The callback receives the parsed options object, typed according to all
-     * `.option()` calls that precede this `.use()` in the chain.
+     * `.option()` calls that precede this `.use()` in the chain, plus an injected
+     * execution context with `{ console, process }` for portable output and exits.
      *
      * @example
      * ```ts
      * cli
      *   .option('--verbose', z.boolean().default(false).describe('Verbose'))
-     *   .use((options) => {
+     *   .use((options, { console }) => {
      *     if (options.verbose) {
-     *       process.env.LOG_LEVEL = 'debug'
+     *       console.log('verbose mode enabled')
      *     }
      *   })
      * ```
@@ -1036,6 +1110,7 @@ class Goke extends EventEmitter {
     }
     runMatchedCommand() {
         const { args, options, matchedCommand: command } = this;
+        const executionContext = this.createExecutionContext();
         if (!command || !command.commandAction)
             return;
         try {
@@ -1060,6 +1135,7 @@ class Goke extends EventEmitter {
             }
         });
         actionArgs.push(options);
+        actionArgs.push(executionContext);
         const executeAction = () => command.commandAction.apply(this, actionArgs);
         const handleAsyncError = (err) => {
             if (err instanceof Error) {
@@ -1076,58 +1152,49 @@ class Goke extends EventEmitter {
         let asyncChain = null;
         for (const mw of this.middlewares) {
             if (asyncChain) {
-                asyncChain = asyncChain.then(() => mw.action(options));
+                asyncChain = asyncChain.then(() => mw.action(options, executionContext));
             }
             else {
                 try {
-                    const mwResult = mw.action(options);
+                    const mwResult = mw.action(options, executionContext);
                     if (isPromiseLike(mwResult)) {
                         asyncChain = mwResult;
                     }
                 }
                 catch (err) {
+                    if (err instanceof GokeProcessExit) {
+                        throw err;
+                    }
                     handleAsyncError(err);
                     return;
                 }
             }
         }
-        const result = asyncChain
-            ? asyncChain.then(executeAction)
-            : executeAction();
-        // If the result is a promise, catch async errors
-        if (isPromiseLike(result)) {
-            result.catch(handleAsyncError);
-        }
-        return result;
-    }
-}
-// ─── openInBrowser ───
-/**
- * Open a URL in the default browser.
- * In non-TTY environments (CI, piped output, agents), prints the URL to stdout instead.
- */
-function openInBrowser(url) {
-    if (!process.stdout.isTTY) {
-        console.error(url);
-        return;
-    }
-    const { execSync } = require('child_process');
-    const platform = process.platform;
-    try {
-        if (platform === 'darwin') {
-            execSync(`open ${JSON.stringify(url)}`, { stdio: 'ignore' });
+        const catchAsyncError = (err) => {
+            if (err instanceof GokeProcessExit) {
+                throw err;
+            }
+            handleAsyncError(err);
+        };
+        if (asyncChain) {
+            return asyncChain
+                .then(executeAction)
+                .catch(catchAsyncError);
         }
-        else if (platform === 'win32') {
-            execSync(`start "" ${JSON.stringify(url)}`, { stdio: 'ignore' });
+        try {
+            const result = executeAction();
+            return isPromiseLike(result)
+                ? result.catch(catchAsyncError)
+                : result;
         }
-        else {
-            execSync(`xdg-open ${JSON.stringify(url)}`, { stdio: 'ignore' });
+        catch (err) {
+            if (err instanceof GokeProcessExit) {
+                throw err;
+            }
+            handleAsyncError(err);
+            return;
         }
     }
-    catch {
-        // fallback: print the URL if open fails
-        console.error(url);
-    }
 }
-export { createConsole, Command, openInBrowser };
+export { createConsole, Command, GokeProcessExit, openInBrowser };
 export default Goke;

package/dist/index.d.ts

@@ -8,8 +8,8 @@ import { Command } from "./goke.js";
 declare const goke: (name?: string, options?: GokeOptions) => Goke<{}>;
 export default goke;
 export { goke, Goke, Command };
-export { createConsole, openInBrowser } from "./goke.js";
-export type { GokeOutputStream, GokeConsole, GokeOptions } from "./goke.js";
+export { createConsole, GokeProcessExit, openInBrowser } from "./goke.js";
+export type { GokeOutputStream, GokeConsole, GokeExecutionContext, GokeOptions, GokeProcess } from "./goke.js";
 export type { StandardTypedV1, StandardJSONSchemaV1, JsonSchema } from "./coerce.js";
 export { GokeError, coerceBySchema, extractJsonSchema, wrapJsonSchema, isStandardSchema, extractSchemaMetadata } from "./coerce.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEnC;;;GAGG;AACH,QAAA,MAAM,IAAI,GAAI,aAAS,EAAE,UAAU,WAAW,aAA4B,CAAA;AAE1E,eAAe,IAAI,CAAA;AACnB,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;AAC9B,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACxD,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAC3E,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACpF,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAA;AAC5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEnC;;;GAGG;AACH,QAAA,MAAM,IAAI,GAAI,aAAS,EAAE,UAAU,WAAW,aAA4B,CAAA;AAE1E,eAAe,IAAI,CAAA;AACnB,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,CAAA;AAC9B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AACzE,YAAY,EAAE,gBAAgB,EAAE,WAAW,EAAE,oBAAoB,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAC9G,YAAY,EAAE,eAAe,EAAE,oBAAoB,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AACpF,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,iBAAiB,EAAE,cAAc,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA"}

package/dist/index.js

@@ -7,5 +7,5 @@ import { Command } from "./goke.js";
 const goke = (name = '', options) => new Goke(name, options);
 export default goke;
 export { goke, Goke, Command };
-export { createConsole, openInBrowser } from "./goke.js";
+export { createConsole, GokeProcessExit, openInBrowser } from "./goke.js";
 export { GokeError, coerceBySchema, extractJsonSchema, wrapJsonSchema, isStandardSchema, extractSchemaMetadata } from "./coerce.js";

package/dist/just-bash.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Runtime adapter that exposes a goke CLI as a JustBash-compatible custom command.
+ *
+ * Structural types here are based on JustBash source definitions:
+ * - https://github.com/vercel-labs/just-bash/blob/main/src/custom-commands.ts
+ * - https://github.com/vercel-labs/just-bash/blob/main/src/types.ts
+ */
+import Goke from './goke.js';
+interface JustBashExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+interface JustBashCommand {
+    name: string;
+    trusted: true;
+    execute(args: string[]): Promise<JustBashExecResult>;
+}
+export declare function createJustBashCommand(cli: Goke<any>, options?: {
+    name?: string;
+}): JustBashCommand;
+export type { JustBashCommand, JustBashExecResult };
+//# sourceMappingURL=just-bash.d.ts.map

package/dist/just-bash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"just-bash.d.ts","sourceRoot":"","sources":["../src/just-bash.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,IAAyB,MAAM,WAAW,CAAA;AAGjD,UAAU,kBAAkB;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,IAAI,CAAA;IACb,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;CACrD;AAcD,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,EACd,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1B,eAAe,CAiDjB;AAED,YAAY,EAAE,eAAe,EAAE,kBAAkB,EAAE,CAAA"}

package/dist/just-bash.js

@@ -0,0 +1,65 @@
+/**
+ * Runtime adapter that exposes a goke CLI as a JustBash-compatible custom command.
+ *
+ * Structural types here are based on JustBash source definitions:
+ * - https://github.com/vercel-labs/just-bash/blob/main/src/custom-commands.ts
+ * - https://github.com/vercel-labs/just-bash/blob/main/src/types.ts
+ */
+import { GokeProcessExit } from './goke.js';
+function createTextCaptureStream() {
+    const chunks = [];
+    return {
+        get text() {
+            return chunks.join('');
+        },
+        write(data) {
+            chunks.push(data);
+        },
+    };
+}
+export function createJustBashCommand(cli, options) {
+    const name = options?.name ?? cli.name;
+    if (!name) {
+        throw new Error('createJustBashCommand() requires the CLI to have a name');
+    }
+    if (name.split(/\s+/).length > 1) {
+        throw new Error('JustBash custom command names must be a single token');
+    }
+    return {
+        name,
+        trusted: true,
+        async execute(args) {
+            const stdout = createTextCaptureStream();
+            const stderr = createTextCaptureStream();
+            const argv = ['node', name, ...args];
+            const cloned = cli.clone({
+                stdout,
+                stderr,
+                argv,
+                exit: (code) => {
+                    throw new GokeProcessExit(code);
+                },
+            });
+            cloned.name = name;
+            try {
+                cloned.parse(argv, { run: false });
+                await cloned.runMatchedCommand();
+                return {
+                    stdout: stdout.text,
+                    stderr: stderr.text,
+                    exitCode: 0,
+                };
+            }
+            catch (error) {
+                if (error instanceof GokeProcessExit) {
+                    return {
+                        stdout: stdout.text,
+                        stderr: stderr.text,
+                        exitCode: error.code,
+                    };
+                }
+                throw error;
+            }
+        },
+    };
+}

package/dist/runtime-browser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Browser-safe runtime stubs for goke core.
+ */
+type Listener = (...args: any[]) => void;
+declare class EventEmitter {
+    #private;
+    on(eventName: string | symbol, listener: Listener): this;
+    emit(eventName: string | symbol, ...args: any[]): boolean;
+    eventNames(): (string | symbol)[];
+    listeners(eventName: string | symbol): Listener[];
+}
+declare const process: {
+    argv: string[];
+    arch: string;
+    platform: string;
+    version: string;
+    stdout: {
+        columns: number;
+        isTTY: boolean;
+        write(_data: string): void;
+    };
+    stderr: {
+        columns: number;
+        isTTY: boolean;
+        write(_data: string): void;
+    };
+    exit(code: number): never;
+};
+declare function openInBrowser(_url: string): void;
+export { EventEmitter, openInBrowser, process };
+//# sourceMappingURL=runtime-browser.d.ts.map

package/dist/runtime-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-browser.d.ts","sourceRoot":"","sources":["../src/runtime-browser.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,KAAK,QAAQ,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAA;AAExC,cAAM,YAAY;;IAGhB,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,QAAQ;IAOjD,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE;IAS/C,UAAU;IAIV,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;CAGrC;AAQD,QAAA,MAAM,OAAO;UACC,MAAM,EAAE;;;;;;;qBAJP,MAAM;;;;;qBAAN,MAAM;;eAUR,MAAM,GAAG,KAAK;CAK1B,CAAA;AAED,iBAAS,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEzC;AAED,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,CAAA"}

package/dist/runtime-browser.js

@@ -0,0 +1,47 @@
+/**
+ * Browser-safe runtime stubs for goke core.
+ */
+class EventEmitter {
+    #listeners = new Map();
+    on(eventName, listener) {
+        const listeners = this.#listeners.get(eventName) ?? [];
+        listeners.push(listener);
+        this.#listeners.set(eventName, listeners);
+        return this;
+    }
+    emit(eventName, ...args) {
+        const listeners = this.#listeners.get(eventName);
+        if (!listeners || listeners.length === 0)
+            return false;
+        for (const listener of listeners) {
+            listener(...args);
+        }
+        return true;
+    }
+    eventNames() {
+        return [...this.#listeners.keys()];
+    }
+    listeners(eventName) {
+        return [...(this.#listeners.get(eventName) ?? [])];
+    }
+}
+const createOutputStream = () => ({
+    columns: Number.POSITIVE_INFINITY,
+    isTTY: false,
+    write(_data) { },
+});
+const process = {
+    argv: [],
+    arch: 'browser',
+    platform: 'browser',
+    version: 'browser',
+    stdout: createOutputStream(),
+    stderr: createOutputStream(),
+    exit(code) {
+        throw new Error(`process.exit(${code}) is not available in the browser runtime. Pass a custom exit handler to goke(...).`);
+    },
+};
+function openInBrowser(_url) {
+    // Browser builds should decide how to surface URLs themselves.
+}
+export { EventEmitter, openInBrowser, process };

package/dist/runtime-node.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Node.js runtime bindings for goke core.
+ */
+import { EventEmitter } from 'events';
+declare const process: NodeJS.Process;
+declare function openInBrowser(url: string): void;
+export { EventEmitter, openInBrowser, process };
+//# sourceMappingURL=runtime-node.d.ts.map

package/dist/runtime-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-node.d.ts","sourceRoot":"","sources":["../src/runtime-node.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAErC,QAAA,MAAM,OAAO,gBAAqB,CAAA;AAElC,iBAAS,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAiBxC;AAED,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,OAAO,EAAE,CAAA"}

package/dist/runtime-node.js

@@ -0,0 +1,27 @@
+/**
+ * Node.js runtime bindings for goke core.
+ */
+import { execSync } from 'child_process';
+import { EventEmitter } from 'events';
+const process = globalThis.process;
+function openInBrowser(url) {
+    if (!process.stdout.isTTY) {
+        process.stderr.write(url + '\n');
+        return;
+    }
+    try {
+        if (process.platform === 'darwin') {
+            execSync(`open ${JSON.stringify(url)}`, { stdio: 'ignore' });
+        }
+        else if (process.platform === 'win32') {
+            execSync(`start "" ${JSON.stringify(url)}`, { stdio: 'ignore' });
+        }
+        else {
+            execSync(`xdg-open ${JSON.stringify(url)}`, { stdio: 'ignore' });
+        }
+    }
+    catch {
+        process.stderr.write(url + '\n');
+    }
+}
+export { EventEmitter, openInBrowser, process };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goke",
-  "version": "6.3.2",
+  "version": "6.4.0",
   "type": "module",
   "description": "Simple yet powerful framework for building command-line apps. Inspired by cac.",
   "repository": {
@@ -21,6 +21,14 @@
   ],
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "imports": {
+    "#runtime": {
+      "types": "./src/runtime-node.ts",
+      "development": "./src/runtime-node.ts",
+      "node": "./dist/runtime-node.js",
+      "default": "./dist/runtime-browser.js"
+    }
+  },
   "exports": {
     "./package.json": "./package.json",
     ".": {

package/src/__test__/just-bash.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Tests for injected execution context, clone isolation, and the JustBash bridge.
+ */
+
+import { describe, expect, test } from 'vitest'
+import { z } from 'zod'
+import goke from '../index.js'
+import type { GokeOutputStream, GokeOptions } from '../index.js'
+
+const ANSI_RE = /\x1B\[[0-9;]*m/g
+
+const stripAnsi = (text: string) => text.replace(ANSI_RE, '')
+
+function createTestOutputStream(): GokeOutputStream & { lines: string[]; readonly text: string } {
+  const lines: string[] = []
+  return {
+    lines,
+    get text() { return stripAnsi(lines.join('')) },
+    write(data: string) { lines.push(data) },
+  }
+}
+
+function gokeTestable(name = '', options?: Partial<GokeOptions>) {
+  return goke(name, {
+    ...options,
+    exit: () => {},
+  })
+}
+
+describe('injected execution context', () => {
+  test('command action receives injected console and process', () => {
+    const stdout = createTestOutputStream()
+    const cli = gokeTestable('mycli', { stdout })
+    let seenArgv: string[] | undefined
+
+    cli
+      .command('status', 'Show status')
+      .action((options, { console, process }) => {
+        console.log('ready')
+        seenArgv = process.argv
+      })
+
+    cli.parse(['node', 'bin', 'status'], { run: true })
+
+    expect(stdout.text).toBe('ready\n')
+    expect(seenArgv).toEqual(['node', 'bin', 'status'])
+  })
+
+  test('middleware receives injected console and process', () => {
+    const stdout = createTestOutputStream()
+    const cli = gokeTestable('mycli', { stdout })
+    let seenArgv: string[] | undefined
+
+    cli
+      .use((options, { console, process }) => {
+        console.log('middleware')
+        seenArgv = process.argv
+      })
+      .command('build', 'Build')
+      .action(() => {})
+
+    cli.parse(['node', 'bin', 'build'], { run: true })
+
+    expect(stdout.text).toBe('middleware\n')
+    expect(seenArgv).toEqual(['node', 'bin', 'build'])
+  })
+})
+
+describe('clone', () => {
+  test('clone creates isolated parse state', () => {
+    const cli = gokeTestable('mycli')
+
+    cli.command('build', 'Build').action(() => {})
+
+    const cloned = (cli as any).clone({ exit: () => {} })
+
+    cloned.parse(['node', 'bin', 'build'], { run: false })
+
+    expect(cloned).not.toBe(cli)
+    expect(cloned.matchedCommandName).toBe('build')
+    expect(cli.matchedCommandName).toBeUndefined()
+  })
+})
+
+describe('createJustBashCommand', () => {
+  test('runs multi-word goke subcommands through one just-bash command', async () => {
+    const cli = gokeTestable('parent')
+
+    cli
+      .command('child commandwithspaces', 'Run nested command')
+      .option('--name <name>', z.string().describe('Name'))
+      .action((options, { console }) => {
+        console.log(`hello ${options.name}`)
+      })
+
+    const customCommand = await (cli as any).createJustBashCommand()
+    const result = await customCommand.execute(['child', 'commandwithspaces', '--name', 'Tommy'])
+
+    expect(result).toEqual({
+      stdout: 'hello Tommy\n',
+      stderr: '',
+      exitCode: 0,
+    })
+  })
+
+  test('maps injected process.exit to a command exit code', async () => {
+    const cli = gokeTestable('parent')
+
+    cli
+      .command('fail', 'Exit with custom code')
+      .action((options, { process }) => {
+        process.exit(7)
+      })
+
+    const customCommand = await (cli as any).createJustBashCommand()
+    const result = await customCommand.execute(['fail'])
+
+    expect(result).toEqual({
+      stdout: '',
+      stderr: '',
+      exitCode: 7,
+    })
+  })
+})

package/src/__test__/types.test-d.ts

@@ -119,9 +119,12 @@ describe('type-level: middleware use() callback inference', () => {
     goke('test')
       .option('--port <port>', schema1)
       .option('--host <host>', schema2)
-      .use((options) => {
+      .use((options, { console, process }) => {
         expectTypeOf(options.port).toEqualTypeOf<number>()
         expectTypeOf(options.host).toEqualTypeOf<string>()
+        expectTypeOf(process.argv).toEqualTypeOf<string[]>()
+        expectTypeOf(process.stdout.write).toEqualTypeOf<(data: string) => void>()
+        expectTypeOf(console.log).toBeFunction()
       })
   })
 
@@ -131,16 +134,18 @@ describe('type-level: middleware use() callback inference', () => {
 
     goke('test')
       .option('--verbose', schema1)
-      .use((options) => {
+      .use((options, { process }) => {
         expectTypeOf(options.verbose).toEqualTypeOf<boolean | undefined>()
+        expectTypeOf(process.exit).toEqualTypeOf<(code: number) => void>()
         // @ts-expect-error port is not declared yet
         options.port
       })
       .option('--port <port>', schema2)
-      .use((options) => {
+      .use((options, { console }) => {
         // Now both are visible
         expectTypeOf(options.verbose).toEqualTypeOf<boolean | undefined>()
         expectTypeOf(options.port).toEqualTypeOf<number>()
+        expectTypeOf(console.error).toBeFunction()
       })
   })
 
@@ -149,7 +154,8 @@ describe('type-level: middleware use() callback inference', () => {
 
     goke('test')
       .option('--port <port>', schema)
-      .use((options) => {
+      .use((options, { process }) => {
+        expectTypeOf(process.stderr.write).toEqualTypeOf<(data: string) => void>()
         // @ts-expect-error nonExistent was never defined
         options.nonExistent
       })