goke 6.3.1 → 6.4.0

package/README.md

@@ -15,6 +15,7 @@
 - **Yet so powerful**. Enable features like default command, git-like subcommands, validation for required arguments and options, variadic arguments, dot-nested options, automated help message generation and so on.
 - **Space-separated subcommands**: Support multi-word commands like `mcp login`, `git remote add`.
 - **Schema-based type coercion**: Use Zod, Valibot, ArkType, or plain JSON Schema for automatic type coercion and TypeScript type inference. Description and default values are extracted from the schema automatically.
+- **Injected execution context**: Prefer `{ console, process }` in actions and middleware for portable output, simpler tests, and alternate runtimes like JustBash.
 - **Type-safe middleware**: Register `.use()` callbacks that run before commands with full type inference from global options.
 - **Developer friendly**. Written in TypeScript.
 
@@ -43,7 +44,7 @@ cli.option(
 )
 cli.option('--name <name>', 'Provide your name')
 
-cli.command('lint [...files]', 'Lint files').action((files, options) => {
+cli.command('lint [...files]', 'Lint files').action((files, options, { console }) => {
   console.log(files, options)
 })
 
@@ -52,7 +53,7 @@ cli
   .option('--minify', 'Minify output')
   .example('build src/index.ts')
   .example('build src/index.ts --minify')
-  .action(async (entry, options) => { // options is type safe! no need to type it
+  .action(async (entry, options, { console }) => { // options is type safe! no need to type it
     console.log(entry, options)
   })
 
@@ -132,7 +133,7 @@ cli
   .option('--channel <name>', 'Target channel: stable, beta, alpha')
   .option('--notes-file <path>', 'Markdown file used as release notes')
   .option('--dry-run', 'Preview every step without publishing')
-  .action((version, options) => {
+  .action((version, options, { console }) => {
     console.log('release', version, options)
   })
 
@@ -158,7 +159,7 @@ cli
   .option('--target <migration>', 'Apply up to a specific migration id')
   .option('--dry-run', 'Print plan only, do not execute SQL')
   .option('--verbose', 'Show each executed statement')
-  .action((options) => {
+  .action((options, { console }) => {
     console.log('migrate', options)
   })
 
@@ -298,7 +299,7 @@ cli
     z.string().default('production').describe('Target environment'),
   )
   .option('--dry-run', 'Preview without deploying')
-  .action((options) => {
+  .action((options, { console }) => {
     console.log(`Deploying to ${options.env}...`)
   })
 
@@ -306,22 +307,22 @@ cli
 cli
   .command('init', 'Initialize a new project')
   .option('--template <template>', 'Project template')
-  .action((options) => {
+  .action((options, { console }) => {
     console.log('Initializing project...')
   })
 
-cli.command('login', 'Authenticate with the server').action(() => {
+cli.command('login', 'Authenticate with the server').action((options, { console }) => {
   console.log('Opening browser for login...')
 })
 
-cli.command('logout', 'Clear saved credentials').action(() => {
+cli.command('logout', 'Clear saved credentials').action((options, { console }) => {
   console.log('Logged out')
 })
 
 cli
   .command('status', 'Show deployment status')
   .option('--json', 'Output as JSON')
-  .action((options) => {
+  .action((options, { console }) => {
     console.log('Fetching status...')
   })
 
@@ -329,7 +330,7 @@ cli
   .command('logs <deploymentId>', 'Stream logs for a deployment')
   .option('--follow', 'Follow log output')
   .option('--lines <n>', z.number().default(100).describe('Number of lines'))
-  .action((deploymentId, options) => {
+  .action((deploymentId, options, { console }) => {
     console.log(`Streaming logs for ${deploymentId}...`)
   })
 
@@ -351,6 +352,8 @@ deploy --help                   # shows all commands
 
 Global options are defined on the CLI instance and apply to all commands. Use `.use()` to register middleware that runs before any command action — useful for reacting to global options like setting up logging, initializing state, or configuring services.
 
+Prefer the injected `{ console, process }` argument over global `console` and `process.exit`. It keeps commands easier to test and lets the same command code run inside alternate runtimes like JustBash.
+
 Middleware runs in registration order, after option parsing and validation, but before the matched command's `.action()` callback.
 
 ```ts
@@ -362,24 +365,24 @@ const cli = goke('mycli')
 cli
   .option('--verbose', z.boolean().default(false).describe('Enable verbose logging'))
   .option('--api-url [url]', z.string().default('https://api.example.com').describe('API base URL'))
-  .use((options) => {
+  .use((options, { console }) => {
     // options.verbose and options.apiUrl are fully typed here
     if (options.verbose) {
-      process.env.LOG_LEVEL = 'debug'
+      console.log('verbose mode enabled')
     }
   })
 
 cli
   .command('deploy <env>', 'Deploy to an environment')
   .option('--dry-run', 'Preview without deploying')
-  .action((env, options) => {
+  .action((env, options, { console }) => {
     // options includes both command options (dryRun) and global options (verbose, apiUrl)
     console.log(`Deploying to ${env} via ${options.apiUrl}`)
   })
 
 cli
   .command('status', 'Show deployment status')
-  .action((options) => {
+  .action((options, { console }) => {
     console.log('Checking status...')
   })
 
@@ -392,14 +395,16 @@ Type safety is positional — each `.use()` callback only sees options declared
 ```ts
 cli
   .option('--verbose', z.boolean().default(false).describe('Verbose'))
-  .use((options) => {
+  .use((options, { process }) => {
     options.verbose   // boolean — typed
+    process.argv      // string[] — typed
     options.port      // TypeScript error — not declared yet
   })
   .option('--port <port>', z.number().describe('Port'))
-  .use((options) => {
+  .use((options, { console }) => {
     options.verbose   // boolean — still visible
     options.port      // number — now visible
+    console.error('ready')
   })
 ```
 
@@ -408,9 +413,10 @@ Middleware supports async functions. If any middleware is async, the remaining m
 ```ts
 cli
   .option('--token <token>', z.string().describe('API token'))
-  .use(async (options) => {
+  .use(async (options, { console }) => {
     const client = await connectToApi(options.token)
     globalState.client = client
+    console.log('connected')
   })
 ```
 
@@ -426,7 +432,7 @@ const cli = goke()
 cli
   .command('rm <dir>', 'Remove a dir')
   .option('-r, --recursive', 'Remove recursively')
-  .action((dir, options) => {
+  .action((dir, options, { console }) => {
     console.log('remove ' + dir + (options.recursive ? ' recursively' : ''))
   })
 
@@ -444,17 +450,17 @@ import { goke } from 'goke'
 
 const cli = goke('mycli')
 
-cli.command('mcp login <url>', 'Login to MCP server').action((url) => {
+cli.command('mcp login <url>', 'Login to MCP server').action((url, options, { console }) => {
   console.log('Logging in to', url)
 })
 
-cli.command('mcp logout', 'Logout from MCP server').action(() => {
+cli.command('mcp logout', 'Logout from MCP server').action((options, { console }) => {
   console.log('Logged out')
 })
 
 cli
   .command('git remote add <name> <url>', 'Add a git remote')
-  .action((name, url) => {
+  .action((name, url, options, { console }) => {
     console.log('Adding remote', name, url)
   })
 
@@ -479,7 +485,7 @@ cli
   .option('--workers <workers>', z.int().describe('Worker count'))
   .option('--tags <tag>', z.array(z.string()).describe('Tags (repeatable)'))
   .option('--verbose', 'Verbose output')
-  .action((options) => {
+  .action((options, { console }) => {
     // options.port is number, options.host is string, etc.
     console.log(options)
   })
@@ -510,7 +516,7 @@ cli
   .option('--old-port <port>', z.number().meta({ deprecated: true, description: 'Use --port instead' }))
   // Current option: visible in help
   .option('--port <port>', z.number().describe('Port number'))
-  .action((options) => {
+  .action((options, { console }) => {
     const port = options.port ?? options.oldPort
     console.log('Starting on port', port)
   })
@@ -525,7 +531,9 @@ When users run `--help`, deprecated options won't appear, but `--old-port 3000`
 
 When using brackets in command name, angled brackets indicate required command arguments, while square brackets indicate optional arguments.
 
-When using brackets in option name, angled brackets indicate that a string / number value is required, while square brackets indicate that the value can also be `true`.
+When using brackets in option name, angled brackets indicate that a string / number value is required, while square brackets indicate that the value is optional.
+
+**Optionality is determined solely by bracket syntax, not by the schema.** `[square brackets]` makes an option optional regardless of whether the schema is `z.string()` or `z.string().optional()`. The schema's `.optional()` is never consulted for this — it only affects type coercion. This means `z.string()` with `[--name]` is treated as optional: if the flag is omitted, `options.name` is `undefined` even though the schema has no `.optional()`.
 
 ### Negated Options
 
@@ -546,7 +554,7 @@ The last argument of a command can be variadic. To make an argument variadic you
 cli
   .command('build <entry> [...otherFiles]', 'Build your app')
   .option('--foo', 'Foo option')
-  .action((entry, otherFiles, options) => {
+  .action((entry, otherFiles, options, { console }) => {
     console.log(entry)
     console.log(otherFiles)
     console.log(options)
@@ -604,7 +612,7 @@ cli
   .command('build', 'desc')
   .option('--env <env>', 'Set envs')
   .example('--env.API_SECRET xxx')
-  .action((options) => {
+  .action((options, { console }) => {
     console.log(options)
   })
 ```
@@ -617,7 +625,7 @@ Register a command that will be used when no other command is matched.
 cli
   .command('[...files]', 'Build files')
   .option('--minimize', 'Minimize output')
-  .action((files, options) => {
+  .action((files, options, { console }) => {
     console.log(files)
     console.log(options.minimize)
   })
@@ -632,11 +640,46 @@ try {
   cli.parse(process.argv, { run: false })
   await cli.runMatchedCommand()
 } catch (error) {
-  console.error(error.stack)
+  const message = error instanceof Error ? error.stack : String(error)
+  process.stderr.write(String(message) + '\n')
   process.exit(1)
 }
 ```
 
+### Testing with mocked console and exit
+
+Because goke derives its injected `{ console, process }` from the CLI's configured output streams and `exit` function, tests can override them directly and assert on the calls.
+
+```ts
+import { describe, expect, test, vi } from 'vitest'
+import { goke, GokeProcessExit } from 'goke'
+
+describe('deploy command', () => {
+  test('writes output and exits with injected mocks', () => {
+    const stdout = { write: vi.fn<(data: string) => void>() }
+    const stderr = { write: vi.fn<(data: string) => void>() }
+    const exit = vi.fn<(code: number) => void>()
+
+    const cli = goke('acme', { stdout, stderr, exit })
+
+    cli
+      .command('deploy', 'Deploy the project')
+      .action((options, { console, process }) => {
+        console.log('deploying')
+        process.exit(2)
+      })
+
+    expect(() => {
+      cli.parse(['node', 'acme', 'deploy'], { run: true })
+    }).toThrow(GokeProcessExit)
+
+    expect(stdout.write).toHaveBeenCalledWith('deploying\n')
+    expect(exit).toHaveBeenCalledWith(2)
+    expect(stderr.write).not.toHaveBeenCalled()
+  })
+})
+```
+
 ### With TypeScript
 
 ```ts
@@ -657,7 +700,7 @@ cli
   .command('serve <entry>', 'Start the app')
   .option('--port <port>', z.number().default(3000).describe('Port number'))
   .option('--watch', 'Watch files')
-  .action((entry, options) => {
+  .action((entry, options, { console }) => {
     // entry: string
     // options.port: number
     // options.watch: boolean
@@ -675,6 +718,33 @@ import { openInBrowser } from 'goke'
 openInBrowser('https://example.com/dashboard')
 ```
 
+### Expose a goke CLI to JustBash
+
+Use `cli.createJustBashCommand()` to expose a goke CLI as a single JustBash custom command. JustBash command names are single-token executables, but the goke CLI behind them can still use multi-word subcommands like `child commandwithspaces`.
+
+```ts
+import { goke } from 'goke'
+import { z } from 'zod'
+import { Bash } from 'just-bash'
+
+const cli = goke('parent')
+
+cli
+  .command('child commandwithspaces', 'Run nested command')
+  .option('--name <name>', z.string().describe('Name'))
+  .action((options, { console }) => {
+    console.log(`hello ${options.name}`)
+  })
+
+const bash = new Bash({
+  customCommands: [await cli.createJustBashCommand()],
+})
+
+await bash.exec('parent child commandwithspaces --name Tommy')
+```
+
+Prefer the injected `{ console, process }` helpers in command implementations so the same command code works cleanly both in the regular CLI runtime and through the JustBash bridge.
+
 ## References
 
 ### CLI Instance
@@ -710,9 +780,9 @@ Add a global option. The second argument is either:
 
 #### cli.use(callback)
 
-- Type: `(callback: (options: Opts) => void | Promise<void>) => CLI`
+- Type: `(callback: (options: Opts, { console, process }) => void | Promise<void>) => CLI`
 
-Register a middleware function that runs before the matched command action. Middleware runs in registration order, after option parsing and validation. The callback receives the parsed global options, typed according to all `.option()` calls that precede the `.use()` in the chain.
+Register a middleware function that runs before the matched command action. Middleware runs in registration order, after option parsing and validation. The callback receives the parsed global options, typed according to all `.option()` calls that precede the `.use()` in the chain, plus an injected `{ console, process }` helper object.
 
 #### cli.parse(argv?)
 
@@ -766,6 +836,8 @@ Basically the same as `cli.option` but this adds the option to specific command.
 
 - Type: `(callback: ActionCallback) => Command`
 
+Command callbacks receive positional args first, then parsed options, then an injected `{ console, process }` object. Prefer those injected helpers over global `console` and `process.exit` so commands stay easier to test and can run inside alternate runtimes like JustBash.
+
 #### command.alias(name)
 
 - Type: `(name: string) => Command`
@@ -796,7 +868,7 @@ cli.on('command:!', () => {
 })
 
 cli.on('command:*', () => {
-  console.error('Invalid command: %s', cli.args.join(' '))
+  process.stderr.write(`Invalid command: ${cli.args.join(' ')}\n`)
   process.exit(1)
 })
 ```

package/dist/__test__/index.test.js

@@ -1436,6 +1436,29 @@ describe('schema description and default extraction', () => {
         expect(stdout.text).not.toContain('--legacy');
         expect(stdout.text).not.toContain('Deprecated global');
     });
+    test('hidden commands are not shown in help output', () => {
+        const stdout = createTestOutputStream();
+        const cli = goke('mycli', { stdout });
+        cli.command('visible', 'A visible command');
+        cli.command('secret', 'A hidden command').hidden();
+        cli.help();
+        cli.parse(['node', 'bin', '--help'], { run: false });
+        expect(stdout.text).toContain('visible');
+        expect(stdout.text).toContain('A visible command');
+        expect(stdout.text).not.toContain('secret');
+        expect(stdout.text).not.toContain('A hidden command');
+    });
+    test('hidden command still parses and runs', () => {
+        const cli = gokeTestable('mycli');
+        let result = {};
+        cli
+            .command('secret', 'A hidden command')
+            .hidden()
+            .option('--value <v>', z.string().describe('some value'))
+            .action((options) => { result = options; });
+        cli.parse(['node', 'bin', 'secret', '--value', 'hello']);
+        expect(result.value).toBe('hello');
+    });
 });
 describe('helpText()', () => {
     test('returns help string without printing', () => {

package/dist/__test__/just-bash.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for injected execution context, clone isolation, and the JustBash bridge.
+ */
+export {};
+//# sourceMappingURL=just-bash.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"just-bash.test.d.ts","sourceRoot":"","sources":["../../src/__test__/just-bash.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/__test__/just-bash.test.js

@@ -0,0 +1,97 @@
+/**
+ * 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';
+const ANSI_RE = /\x1B\[[0-9;]*m/g;
+const stripAnsi = (text) => text.replace(ANSI_RE, '');
+function createTestOutputStream() {
+    const lines = [];
+    return {
+        lines,
+        get text() { return stripAnsi(lines.join('')); },
+        write(data) { lines.push(data); },
+    };
+}
+function gokeTestable(name = '', options) {
+    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;
+        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;
+        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.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.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.createJustBashCommand();
+        const result = await customCommand.execute(['fail']);
+        expect(result).toEqual({
+            stdout: '',
+            stderr: '',
+            exitCode: 7,
+        });
+    });
+});

package/dist/__test__/types.test-d.js

@@ -73,9 +73,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();
             expectTypeOf(options.host).toEqualTypeOf();
+            expectTypeOf(process.argv).toEqualTypeOf();
+            expectTypeOf(process.stdout.write).toEqualTypeOf();
+            expectTypeOf(console.log).toBeFunction();
         });
     });
     test('use() only sees options declared before it', () => {
@@ -83,23 +86,26 @@ describe('type-level: middleware use() callback inference', () => {
         const schema2 = {};
         goke('test')
             .option('--verbose', schema1)
-            .use((options) => {
+            .use((options, { process }) => {
             expectTypeOf(options.verbose).toEqualTypeOf();
+            expectTypeOf(process.exit).toEqualTypeOf();
             // @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();
             expectTypeOf(options.port).toEqualTypeOf();
+            expectTypeOf(console.error).toBeFunction();
         });
     });
     test('accessing a non-existent option is a type error', () => {
         const schema = {};
         goke('test')
             .option('--port <port>', schema)
-            .use((options) => {
+            .use((options, { process }) => {
+            expectTypeOf(process.stderr.write).toEqualTypeOf();
             // @ts-expect-error nonExistent was never defined
             options.nonExistent;
         });

package/dist/goke.d.ts

@@ -9,8 +9,8 @@
  * - createConsole: factory for console-like objects from output streams
  * - Utility functions: string helpers, bracket parsing, dot-prop access
  */
-import { EventEmitter } from 'events';
 import type { StandardJSONSchemaV1 } from "./coerce.js";
+import { EventEmitter, openInBrowser } from '#runtime';
 declare class Option {
     rawName: string;
     /** Option name */
@@ -34,6 +34,7 @@ declare class Option {
      *   When a schema is provided, description and default are extracted from the JSON Schema.
      */
     constructor(rawName: string, descriptionOrSchema?: string | StandardJSONSchemaV1);
+    clone(): Option;
 }
 /**
  * Converts a kebab-case string to camelCase at the type level.
@@ -101,6 +102,7 @@ declare class Command {
     examples: CommandExample[];
     helpCallback?: HelpCallback;
     globalCommand?: GlobalCommand;
+    _hidden?: boolean;
     constructor(rawName: string, description: string, config: CommandConfig | undefined, cli: Goke<any>);
     usage(text: string): this;
     allowUnknownOptions(): this;
@@ -128,6 +130,7 @@ declare class Command {
     };
     option(rawName: string, descriptionOrSchema?: string | StandardJSONSchemaV1): this;
     alias(name: string): this;
+    hidden(): this;
     action(callback: (...args: any[]) => any): this;
     isMatched(args: string[]): {
         matched: boolean;
@@ -177,6 +180,22 @@ interface GokeOutputStream {
 interface GokeConsole {
     log(...args: unknown[]): void;
     error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+}
+interface GokeProcess {
+    argv: string[];
+    stdout: GokeOutputStream;
+    stderr: GokeOutputStream;
+    exit(code: number): never | void;
+}
+interface GokeExecutionContext {
+    console: GokeConsole;
+    process: GokeProcess;
+}
+declare class GokeProcessExit extends Error {
+    code: number;
+    constructor(code: number);
 }
 /**
  * Options for configuring a Goke CLI instance.
@@ -217,7 +236,7 @@ declare class Goke<Opts extends Record<string, any> = {}> extends EventEmitter {
     commands: Command[];
     /** Middleware functions that run before the matched command action, in registration order */
     middlewares: Array<{
-        action: (options: any) => void | Promise<void>;
+        action: (options: any, context: GokeExecutionContext) => void | Promise<void>;
     }>;
     globalCommand: GlobalCommand;
     matchedCommand?: Command;
@@ -251,6 +270,11 @@ declare class Goke<Opts extends Record<string, any> = {}> extends EventEmitter {
      * @param options Configuration for stdout, stderr, and argv
      */
     constructor(name?: string, options?: GokeOptions);
+    clone(options?: GokeOptions): Goke<Opts>;
+    private createExecutionContext;
+    createJustBashCommand(options?: {
+        name?: string;
+    }): Promise<import("./just-bash.js").JustBashCommand>;
     /**
      * Add a global usage text.
      *
@@ -279,20 +303,21 @@ declare class Goke<Opts extends Record<string, any> = {}> 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')
      *     }
      *   })
      * ```
      */
-    use(callback: (options: Opts) => void | Promise<void>): this;
+    use(callback: (options: Opts, context: GokeExecutionContext) => void | Promise<void>): this;
     /**
      * Show help message when `-h, --help` flags appear.
      *
@@ -349,12 +374,7 @@ declare class Goke<Opts extends Record<string, any> = {}> extends EventEmitter {
     private mri;
     runMatchedCommand(): any;
 }
-/**
- * Open a URL in the default browser.
- * In non-TTY environments (CI, piped output, agents), prints the URL to stdout instead.
- */
-declare function openInBrowser(url: string): void;
-export type { GokeOutputStream, GokeConsole, GokeOptions };
-export { createConsole, Command, openInBrowser };
+export type { GokeOutputStream, GokeConsole, GokeOptions, GokeProcess, GokeExecutionContext };
+export { createConsole, Command, GokeProcessExit, openInBrowser };
 export default Goke;
 //# sourceMappingURL=goke.d.ts.map