goke 6.8.0 → 6.9.0

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

@@ -389,4 +389,28 @@ describe('createJustBashCommand', () => {
       exitCode: 7,
     })
   })
+
+  test('truncates captured output to just-bash maxOutputSize and appends a notice', async () => {
+    const { Bash } = await import('just-bash')
+    const cli = gokeTestable('parent')
+
+    cli
+      .command('spam-stderr', 'Write too much stderr')
+      .action((options, { console }) => {
+        console.error('x'.repeat(60))
+        console.error('y'.repeat(60))
+      })
+
+    const bash = new Bash({
+      executionLimits: { maxOutputSize: 80 },
+      customCommands: [await cli.createJustBashCommand()],
+    })
+
+    const result = await bash.exec('parent spam-stderr')
+
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toBe('')
+    expect(result.stderr.length).toBeLessThanOrEqual(80)
+    expect(result.stderr).toBe(`${'x'.repeat(60)}\n[output truncated]\n`)
+  })
 })

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

@@ -481,6 +481,47 @@ describe('type-level: README TypeScript examples', () => {
       })
   })
 
+  test('use() with sub-CLI preserves parent middleware typing', () => {
+    const sub = goke()
+    sub
+      .command('deploy', 'Deploy the app')
+      .option('--force', z.boolean())
+      .action((options) => {
+        // Sub-CLI command's action sees its own options
+        expectTypeOf(options.force).toEqualTypeOf<boolean | undefined>()
+      })
+
+    goke('test')
+      .option('--verbose', z.boolean().default(false).describe('Verbose'))
+      .use(sub)
+      .use((options) => {
+        // Parent middleware still sees parent's accumulated options after .use(subCli)
+        expectTypeOf(options.verbose).toEqualTypeOf<boolean>()
+      })
+      .command('build', 'Build')
+      .option('--target <target>', z.string())
+      .action((options) => {
+        // Parent's inline command still sees global options
+        expectTypeOf(options.verbose).toEqualTypeOf<boolean>()
+        expectTypeOf(options.target).toEqualTypeOf<string>()
+      })
+  })
+
+  test('use() with sub-CLI does not leak sub-CLI types to parent', () => {
+    const sub = goke()
+      .option('--sub-only <val>', z.string())
+    sub.command('sub-cmd', 'Sub command').action(() => {})
+
+    goke('test')
+      .option('--parent-only <val>', z.number())
+      .use(sub)
+      .use((options) => {
+        expectTypeOf(options.parentOnly).toEqualTypeOf<number>()
+        // @ts-expect-error subOnly is not declared on the parent
+        options.subOnly
+      })
+  })
+
   test('README global options and middleware example stays typed end-to-end', () => {
     // `z.boolean().default(false)` and `z.string().default(...)` are
     // effectively required at runtime: the default applies when the flag is

package/src/goke.ts

@@ -1381,14 +1381,48 @@ class Goke<Opts = {}> extends EventEmitter {
    *     }
    *   })
    * ```
+   *
+   * Alternatively, pass another `Goke` instance to compose commands from
+   * separate files. All commands defined on the sub-CLI are merged into
+   * this CLI. Middlewares and global options from the sub-CLI are NOT
+   * copied; only commands are composed.
+   *
+   * @example
+   * ```ts
+   * // selfhost.ts
+   * export const selfhostCli = goke()
+   * selfhostCli
+   *   .command('selfhost', 'Set up on your own workspace')
+   *   .option('-t, --token [token]', 'Admin token')
+   *   .action((options) => { ... })
+   *
+   * // main.ts
+   * import { selfhostCli } from './selfhost.js'
+   * goke('mycli')
+   *   .use(selfhostCli)
+   *   .help()
+   *   .parse(process.argv)
+   * ```
    */
+  use(subCli: Goke<any>): this
   use(
     callback: (
       options: Opts & DoubleDashOptions,
       context: GokeExecutionContext,
     ) => void | Promise<void>,
+  ): this
+  use(
+    callbackOrCli:
+      | Goke<any>
+      | ((options: Opts & DoubleDashOptions, context: GokeExecutionContext) => void | Promise<void>),
   ): this {
-    this.middlewares.push({ action: callback })
+    if (callbackOrCli instanceof Goke) {
+      for (const command of callbackOrCli.commands) {
+        this.commands.push(cloneCommandInto(command, this))
+      }
+      return this
+    }
+    this.middlewares.push({ action: callbackOrCli })
     return this
   }
 

package/src/just-bash.ts

@@ -26,17 +26,90 @@ interface JustBashCommand {
   execute(args: string[], context?: JustBashExecutionContext): Promise<JustBashExecResult>
 }
 
-type JustBashExecutionContext = Pick<CommandContext, 'cwd' | 'env' | 'fs' | 'stdin'>
-type JustBashEncoding = 'utf8' | 'utf-8' | 'ascii' | 'binary' | 'base64' | 'hex' | 'latin1'
+type JustBashExecutionContext = Pick<CommandContext, 'cwd' | 'env' | 'fs' | 'stdin' | 'limits'>
+
+const TRUNCATION_MESSAGE = '\n[output truncated]\n'
+
+function createTextCaptureStreams(maxLength?: number): {
+  stdout: GokeOutputStream
+  stderr: GokeOutputStream
+  getResult(): { stdout: string; stderr: string }
+} {
+  const stdoutChunks: string[] = []
+  const stderrChunks: string[] = []
+  const limit = maxLength != null && maxLength > 0 ? maxLength : Number.POSITIVE_INFINITY
+  let totalLength = 0
+  let stdoutTruncated = false
+  let stderrTruncated = false
+
+  const createStream = (stream: 'stdout' | 'stderr'): GokeOutputStream => ({
+    write(data: string) {
+      if (totalLength >= limit) {
+        if (stream === 'stdout') {
+          stdoutTruncated = true
+        } else {
+          stderrTruncated = true
+        }
+        return
+      }
 
-function createTextCaptureStream(): GokeOutputStream & { readonly text: string } {
-  const chunks: string[] = []
-  return {
-    get text() {
-      return chunks.join('')
+      const remaining = limit - totalLength
+      const text = data.length <= remaining ? data : data.slice(0, remaining)
+      if (stream === 'stdout') {
+        stdoutChunks.push(text)
+        stdoutTruncated ||= text.length !== data.length
+      } else {
+        stderrChunks.push(text)
+        stderrTruncated ||= text.length !== data.length
+      }
+      totalLength += text.length
     },
-    write(data: string) {
-      chunks.push(data)
+  })
+
+  const trimEnd = (value: string, count: number) => value.slice(0, Math.max(0, value.length - count))
+
+  return {
+    stdout: createStream('stdout'),
+    stderr: createStream('stderr'),
+    getResult() {
+      let stdout = stdoutChunks.join('')
+      let stderr = stderrChunks.join('')
+
+      if (!stdoutTruncated && !stderrTruncated) {
+        return { stdout, stderr }
+      }
+
+      const target = stderrTruncated ? 'stderr' : 'stdout'
+      const message = limit === Number.POSITIVE_INFINITY
+        ? TRUNCATION_MESSAGE
+        : TRUNCATION_MESSAGE.slice(0, Math.min(TRUNCATION_MESSAGE.length, limit))
+
+      let overflow = stdout.length + stderr.length + message.length - limit
+      if (Number.isFinite(limit) && overflow > 0) {
+        if (target === 'stderr') {
+          const stderrTrim = Math.min(overflow, stderr.length)
+          stderr = trimEnd(stderr, stderrTrim)
+          overflow -= stderrTrim
+          if (overflow > 0) {
+            stdout = trimEnd(stdout, overflow)
+          }
+        } else {
+          const stdoutTrim = Math.min(overflow, stdout.length)
+          stdout = trimEnd(stdout, stdoutTrim)
+          overflow -= stdoutTrim
+          if (overflow > 0) {
+            stderr = trimEnd(stderr, overflow)
+          }
+        }
+      }
+
+      if (target === 'stderr') {
+        stderr += message
+      } else {
+        stdout += message
+      }
+
+      return { stdout, stderr }
     },
   }
 }
@@ -55,7 +128,7 @@ const getEncoding = (options?: GokeFsEncodingOption) => {
   return options.encoding
 }
 
-const toJustBashEncoding = (encoding?: BufferEncoding | null): JustBashEncoding | null | undefined => {
+const toJustBashEncoding = (encoding?: BufferEncoding | null): 'utf8' | 'utf-8' | 'ascii' | 'binary' | 'base64' | 'hex' | 'latin1' | null | undefined => {
   if (encoding == null) {
     return encoding
   }
@@ -232,16 +305,15 @@ export function createJustBashCommand(
     name,
     trusted: true,
     async execute(args: string[], context?: JustBashExecutionContext) {
-      const stdout = createTextCaptureStream()
-      const stderr = createTextCaptureStream()
+      const output = createTextCaptureStreams(context?.limits?.maxOutputSize)
       const argv = ['node', name, ...args]
       const cloned = cli.clone({
         cwd: context?.cwd,
         env: context ? createJustBashEnvProxy(context.env) : cli.env,
         fs: context ? createJustBashFs(context.fs, context.cwd) : cli.fs,
         stdin: context?.stdin,
-        stdout,
-        stderr,
+        stdout: output.stdout,
+        stderr: output.stderr,
         argv,
         exit: (code) => {
           throw new GokeProcessExit(code)
@@ -253,16 +325,18 @@ export function createJustBashCommand(
       try {
         cloned.parse(argv, { run: false })
         await cloned.runMatchedCommand()
+        const result = output.getResult()
         return {
-          stdout: stdout.text,
-          stderr: stderr.text,
+          stdout: result.stdout,
+          stderr: result.stderr,
           exitCode: 0,
         }
       } catch (error) {
         if (error instanceof GokeProcessExit) {
+          const result = output.getResult()
           return {
-            stdout: stdout.text,
-            stderr: stderr.text,
+            stdout: result.stdout,
+            stderr: result.stderr,
             exitCode: error.code,
           }
         }