@marcusrbrown/infra 0.4.10 → 0.5.0

package/src/commands/status.test.ts

@@ -1,139 +1,123 @@
-import {afterEach, beforeEach, describe, expect, it, spyOn} from 'bun:test'
+import type {StatusSummary} from './status'
+import {describe, expect, it} from 'bun:test'
 import {goke} from 'goke'
+import {createCapturedCtx, expectCapturedToInclude} from '../__test__/mcp-ctx-fixture'
+import {registerStatus, unifiedStatusAction} from './status'
+
+const healthyKeeweb: StatusSummary = {
+  app: 'keeweb',
+  http: 'OK',
+  lastDeploy: '2026-04-12 10:00',
+  version: '—',
+  contentHash: 'match',
+  usageStats: '—',
+}
+
+const healthyCliproxy: StatusSummary = {
+  app: 'cliproxy',
+  http: 'OK',
+  lastDeploy: '—',
+  version: 'v1.2.3',
+  contentHash: '—',
+  usageStats: '12 req / 0 fail',
+}
 
-import {registerStatus} from './status'
+const healthyGateway: StatusSummary = {
+  app: 'gateway',
+  http: 'OK: gateway:running/healthy',
+  lastDeploy: '—',
+  version: '—',
+  contentHash: '—',
+  usageStats: '—',
+}
 
-declare const process: {
-  exitCode?: number
+function makeDeps(overrides?: Partial<Parameters<typeof registerStatus>[1]>): Parameters<typeof registerStatus>[1] {
+  return {
+    getKeewebStatusSummary: async () => healthyKeeweb,
+    getCliproxyStatusSummary: async () => healthyCliproxy,
+    getGatewayStatusSummary: async () => healthyGateway,
+    ...overrides,
+  }
 }
 
-describe('top-level status command', () => {
-  let logSpy: {mockRestore: () => void; mock: {calls: unknown[][]}}
+describe('top-level status command (Tier-2 ctx capture)', () => {
+  it('prints a unified table when all apps are healthy', async () => {
+    const {ctx, captured} = createCapturedCtx()
 
-  beforeEach(() => {
-    logSpy = spyOn(console, 'log').mockImplementation(() => undefined)
-    process.exitCode = 0
-  })
+    await unifiedStatusAction({}, ctx, makeDeps())
 
-  afterEach(() => {
-    logSpy.mockRestore()
-    process.exitCode = 0
+    expect(
+      expectCapturedToInclude(captured, '| App | HTTP | Last Deploy | Version | Content Hash | Usage Stats |'),
+    ).toBe(true)
+    expect(expectCapturedToInclude(captured, '| keeweb | OK | 2026-04-12 10:00 | — | match | — |')).toBe(true)
+    expect(expectCapturedToInclude(captured, '| cliproxy | OK | — | v1.2.3 | — | 12 req / 0 fail |')).toBe(true)
+    expect(expectCapturedToInclude(captured, '| gateway | OK: gateway:running/healthy | — | — | — | — |')).toBe(true)
   })
 
-  async function runStatusCommand(
-    args: string[],
-    dependencies: Parameters<typeof registerStatus>[1],
-  ): Promise<string[]> {
-    const cli = goke('test')
-    registerStatus(cli, dependencies)
-    cli.parse(['bun', 'test', 'status', ...args], {run: false})
-    await cli.runMatchedCommand()
+  it('shows an error row when one app fails and keeps the other results', async () => {
+    const {ctx, captured} = createCapturedCtx()
 
-    return logSpy.mock.calls.map((call: unknown[]) => call.map((value: unknown) => String(value)).join(' '))
-  }
-
-  it('prints a unified table when both apps are healthy', async () => {
-    const lines = await runStatusCommand([], {
-      getKeewebStatusSummary: async () => ({
-        app: 'keeweb',
-        http: 'OK',
-        lastDeploy: '2026-04-12 10:00',
-        version: '—',
-        contentHash: 'match',
-        usageStats: '—',
-      }),
-      getCliproxyStatusSummary: async () => ({
-        app: 'cliproxy',
-        http: 'OK',
-        lastDeploy: '—',
-        version: 'v1.2.3',
-        contentHash: '—',
-        usageStats: '12 req / 0 fail',
+    await unifiedStatusAction(
+      {},
+      ctx,
+      makeDeps({
+        getKeewebStatusSummary: async () => {
+          throw new Error('Keeweb exploded')
+        },
       }),
-      getGatewayStatusSummary: async () => ({
-        app: 'gateway',
-        http: 'OK: gateway:running/healthy',
-        lastDeploy: '—',
-        version: '—',
-        contentHash: '—',
-        usageStats: '—',
-      }),
-    })
+    )
 
-    expect(lines).toContain('| App | HTTP | Last Deploy | Version | Content Hash | Usage Stats |')
-    expect(lines).toContain('| keeweb | OK | 2026-04-12 10:00 | — | match | — |')
-    expect(lines).toContain('| cliproxy | OK | — | v1.2.3 | — | 12 req / 0 fail |')
-    expect(lines).toContain('| gateway | OK: gateway:running/healthy | — | — | — | — |')
+    expect(
+      expectCapturedToInclude(
+        captured,
+        '| keeweb | ❌ Keeweb exploded | ❌ Keeweb exploded | ❌ Keeweb exploded | ❌ Keeweb exploded | ❌ Keeweb exploded |',
+      ),
+    ).toBe(true)
+    expect(expectCapturedToInclude(captured, '| cliproxy | OK | — | v1.2.3 | — | 12 req / 0 fail |')).toBe(true)
+    // Rejection reason must also appear in stderr so MCP consumers can see it
+    expect(captured.stderr.join('')).toContain('keeweb status check failed: Keeweb exploded')
   })
 
-  it('shows an error row when one app fails and keeps the other result', async () => {
-    const lines = await runStatusCommand([], {
-      getKeewebStatusSummary: async () => {
-        throw new Error('Keeweb exploded')
-      },
-      getCliproxyStatusSummary: async () => ({
-        app: 'cliproxy',
-        http: 'OK',
-        lastDeploy: '—',
-        version: 'v1.2.3',
-        contentHash: '—',
-        usageStats: '12 req / 0 fail',
-      }),
-      getGatewayStatusSummary: async () => ({
-        app: 'gateway',
-        http: 'OK: gateway:running/healthy',
-        lastDeploy: '—',
-        version: '—',
-        contentHash: '—',
-        usageStats: '—',
-      }),
-    })
-
-    expect(lines).toContain(
-      '| keeweb | ❌ Keeweb exploded | ❌ Keeweb exploded | ❌ Keeweb exploded | ❌ Keeweb exploded | ❌ Keeweb exploded |',
-    )
-    expect(lines).toContain('| cliproxy | OK | — | v1.2.3 | — | 12 req / 0 fail |')
-  })
+  it('prints valid json with all app keys when --json is passed', async () => {
+    const {ctx, captured} = createCapturedCtx()
 
-  it('prints valid json with both app keys when --json is passed', async () => {
-    const lines = await runStatusCommand(['--json'], {
-      getKeewebStatusSummary: async () => ({
-        app: 'keeweb',
-        http: 'OK',
-        lastDeploy: '2026-04-12 10:00',
-        version: '—',
-        contentHash: 'match',
-        usageStats: '—',
-      }),
-      getCliproxyStatusSummary: async () => ({
-        app: 'cliproxy',
-        http: 'OK',
-        lastDeploy: '—',
-        version: 'v1.2.3',
-        contentHash: '—',
-        usageStats: '12 req / 0 fail',
-      }),
-      getGatewayStatusSummary: async () => ({
-        app: 'gateway',
-        http: 'OK: gateway:running/healthy',
-        lastDeploy: '—',
-        version: '—',
-        contentHash: '—',
-        usageStats: '—',
-      }),
-    })
+    await unifiedStatusAction({json: true}, ctx, makeDeps())
 
-    expect(lines).toHaveLength(1)
+    expect(captured.stdout).toHaveLength(1)
 
-    const [jsonOutput] = lines
+    const [jsonOutput] = captured.stdout
     expect(jsonOutput).toBeDefined()
 
     const parsed = JSON.parse(jsonOutput ?? '{}') as {
       keeweb: {http: string}
       cliproxy: {version: string}
+      gateway: {http: string}
     }
 
     expect(parsed.keeweb.http).toBe('OK')
     expect(parsed.cliproxy.version).toBe('v1.2.3')
+    expect(parsed.gateway.http).toBe('OK: gateway:running/healthy')
+  })
+
+  it('does not write to global console (output is captured via ctx)', async () => {
+    const {ctx, captured} = createCapturedCtx()
+
+    await unifiedStatusAction({}, ctx, makeDeps())
+
+    // Verify output went to ctx capture, not global console
+    expect(captured.stdout.length).toBeGreaterThan(0)
+    expect(expectCapturedToInclude(captured, '| App |')).toBe(true)
+  })
+})
+
+describe('top-level status command (registerStatus wiring)', () => {
+  it('wires through goke without throwing', async () => {
+    const cli = goke('test')
+
+    registerStatus(cli, makeDeps())
+    cli.parse(['bun', 'test', 'status'], {run: false})
+
+    // Verify the command runs without throwing (goke uses its own ctx for output)
+    await expect(cli.runMatchedCommand()).resolves.toBeUndefined()
   })
 })

package/src/commands/status.ts

@@ -1,5 +1,7 @@
 import type {goke} from 'goke'
 
+import type {ActionCtx} from '../lib/action-ctx'
+
 import {z} from 'zod'
 
 import {getCliproxyStatusSummary} from './cliproxy/status'
@@ -69,6 +71,49 @@ function formatRow(row: StatusSummary): string {
   return `| ${values.join(' | ')} |`
 }
 
+export async function unifiedStatusAction(
+  options: {json?: boolean; verbose?: boolean},
+  ctx: ActionCtx,
+  dependencies: StatusDependencies = {
+    getKeewebStatusSummary,
+    getCliproxyStatusSummary,
+    getGatewayStatusSummary,
+  },
+): Promise<void> {
+  const verbose = options.verbose === true
+  const cliproxyBaseUrl = stripTrailingSlash(process.env.CLIPROXY_URL ?? DEFAULT_CLIPROXY_URL)
+  const cliproxyKey = process.env.CLIPROXY_MANAGEMENT_KEY ?? ''
+  const gatewayHost = process.env.GATEWAY_HOST ?? ''
+
+  const results = await Promise.allSettled([
+    dependencies.getKeewebStatusSummary(verbose),
+    dependencies.getCliproxyStatusSummary(cliproxyBaseUrl, cliproxyKey, verbose),
+    dependencies.getGatewayStatusSummary(gatewayHost),
+  ])
+
+  const appNames: AppName[] = ['keeweb', 'cliproxy', 'gateway']
+  const rows: StatusSummary[] = results.map((result, index) => {
+    const app = appNames[index] ?? 'keeweb'
+    if (result.status === 'fulfilled') {
+      return result.value
+    }
+    const reason = result.reason
+    const message = reason instanceof Error ? reason.message : String(reason)
+    ctx.console.error(`${app} status check failed: ${message}`)
+    return errorSummary(app, reason)
+  })
+
+  if (options.json === true) {
+    ctx.console.log(JSON.stringify(toJsonPayload(rows)))
+    return
+  }
+
+  ctx.console.log('| App | HTTP | Last Deploy | Version | Content Hash | Usage Stats |')
+  for (const row of rows) {
+    ctx.console.log(formatRow(row))
+  }
+}
+
 export function registerStatus(
   cli: ReturnType<typeof goke>,
   dependencies: StatusDependencies = {
@@ -87,32 +132,5 @@ export function registerStatus(
       '--verbose',
       z.boolean().describe('Include verbose per-app health check details when building the summary rows.'),
     )
-    .action(async options => {
-      const verbose = options.verbose === true
-      const cliproxyBaseUrl = stripTrailingSlash(process.env.CLIPROXY_URL ?? DEFAULT_CLIPROXY_URL)
-      const cliproxyKey = process.env.CLIPROXY_MANAGEMENT_KEY ?? ''
-      const gatewayHost = process.env.GATEWAY_HOST ?? ''
-
-      const results = await Promise.allSettled([
-        dependencies.getKeewebStatusSummary(verbose),
-        dependencies.getCliproxyStatusSummary(cliproxyBaseUrl, cliproxyKey, verbose),
-        dependencies.getGatewayStatusSummary(gatewayHost),
-      ])
-
-      const appNames: AppName[] = ['keeweb', 'cliproxy', 'gateway']
-      const rows: StatusSummary[] = results.map((result, index) => {
-        const app = appNames[index] ?? 'keeweb'
-        return result.status === 'fulfilled' ? result.value : errorSummary(app, result.reason)
-      })
-
-      if (options.json === true) {
-        console.log(JSON.stringify(toJsonPayload(rows)))
-        return
-      }
-
-      console.log('| App | HTTP | Last Deploy | Version | Content Hash | Usage Stats |')
-      for (const row of rows) {
-        console.log(formatRow(row))
-      }
-    })
+    .action((options, ctx) => unifiedStatusAction(options, ctx, dependencies))
 }

package/src/lib/action-ctx.ts

@@ -0,0 +1,25 @@
+/**
+ * Minimal `ctx` interface every MCP-capturable action accepts.
+ *
+ * Structural subtype of goke's real `GokeExecutionContext` — actions
+ * consume only `console.{log,error}`, `process.{stdout,stderr}.write`,
+ * and `process.exit`, never the `fs` surface. Source files import this
+ * shape from this module so the action contract is defined in one place.
+ *
+ * The `write` parameter is `string` (narrower than goke's real
+ * `string | Uint8Array`) because every action passes string values;
+ * `CapturedCtx.write(string | Uint8Array)` is still assignable to
+ * `ActionCtx.write(string)` via contravariance, so tests using
+ * `CapturedCtx` satisfy this interface.
+ */
+export interface ActionCtx {
+  console: {
+    log: (...args: unknown[]) => void
+    error: (...args: unknown[]) => void
+  }
+  process: {
+    stdout: {write: (chunk: string) => void}
+    stderr: {write: (chunk: string) => void}
+    exit: (code: number) => never | void
+  }
+}