@marcusrbrown/infra 0.4.11 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcusrbrown/infra",
-  "version": "0.4.11",
+  "version": "0.6.0",
   "description": "Infrastructure management CLI — deploy automation, health checks, and MCP bridge",
   "keywords": [
     "infra",
@@ -36,6 +36,7 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
     "yaml": "2.9.0"
   },
   "engines": {

package/src/__snapshots__/cli.test.ts.snap

@@ -71,7 +71,7 @@ Commands:
     --key [key]                        Management API key. Falls back to CLIPROXY_MANAGEMENT_KEY when omitted.
 
 
-  cliproxy login <provider>            Run provider login on the remote CLIProxyAPI host and print OAuth URL output.
+  cliproxy login <provider>            Run provider login on the remote CLIProxyAPI host. Supported providers: claude, codex.
 
     --host [host]                      CLIProxyAPI droplet host for SSH execution. Falls back to CLIPROXY_DOMAIN or cliproxy.fro.bot.
 

package/src/__test__/mcp-ctx-fixture.test.ts

@@ -0,0 +1,108 @@
+import {describe, expect, it} from 'bun:test'
+
+import {createCapturedCtx, expectCapturedToInclude} from './mcp-ctx-fixture'
+
+describe('createCapturedCtx', () => {
+  describe('ctx.console.log', () => {
+    it('populates captured.stdout with a single string arg', () => {
+      const {ctx, captured} = createCapturedCtx()
+      ctx.console.log('hello')
+      expect(captured.stdout).toEqual(['hello'])
+    })
+
+    it('space-joins multiple args matching console.log behavior', () => {
+      const {ctx, captured} = createCapturedCtx()
+      ctx.console.log('foo', 'bar', 42)
+      expect(captured.stdout).toEqual(['foo bar 42'])
+    })
+  })
+
+  describe('ctx.process.stdout.write', () => {
+    it('pushes a string chunk to captured.stdout', () => {
+      const {ctx, captured} = createCapturedCtx()
+      ctx.process.stdout.write('chunk')
+      expect(captured.stdout).toEqual(['chunk'])
+    })
+
+    it('decodes a Uint8Array chunk as utf-8 and pushes to captured.stdout', () => {
+      const {ctx, captured} = createCapturedCtx()
+      ctx.process.stdout.write(new TextEncoder().encode('buf'))
+      expect(captured.stdout).toEqual(['buf'])
+    })
+  })
+
+  describe('ctx.process.stderr.write', () => {
+    it('pushes a string chunk to captured.stderr', () => {
+      const {ctx, captured} = createCapturedCtx()
+      ctx.process.stderr.write('err-chunk')
+      expect(captured.stderr).toEqual(['err-chunk'])
+    })
+  })
+
+  describe('ctx.console.error', () => {
+    it('pushes formatted string to captured.stderr', () => {
+      const {ctx, captured} = createCapturedCtx()
+      ctx.console.error('oops', 99)
+      expect(captured.stderr).toEqual(['oops 99'])
+    })
+  })
+
+  describe('ctx.process.exit', () => {
+    it('throws after populating captured.exit with code 1', () => {
+      const {ctx, captured} = createCapturedCtx()
+      let threw = false
+      try {
+        ctx.process.exit(1)
+      } catch {
+        threw = true
+      }
+      expect(threw).toBe(true)
+      expect(captured.exit).toEqual({code: 1})
+    })
+
+    it('also throws for exit code 0', () => {
+      const {ctx, captured} = createCapturedCtx()
+      let threw = false
+      try {
+        ctx.process.exit(0)
+      } catch {
+        threw = true
+      }
+      expect(threw).toBe(true)
+      expect(captured.exit).toEqual({code: 0})
+    })
+  })
+
+  it('starts with empty stdout, stderr, and null exit', () => {
+    const {captured} = createCapturedCtx()
+    expect(captured.stdout).toEqual([])
+    expect(captured.stderr).toEqual([])
+    expect(captured.exit).toBeNull()
+  })
+})
+
+describe('expectCapturedToInclude', () => {
+  it('returns true when stdout contains the string marker', () => {
+    const {ctx, captured} = createCapturedCtx()
+    ctx.console.log('hello world')
+    expect(expectCapturedToInclude(captured, 'hello')).toBe(true)
+  })
+
+  it('returns false when stdout does not contain the string marker', () => {
+    const {ctx, captured} = createCapturedCtx()
+    ctx.console.log('goodbye')
+    expect(expectCapturedToInclude(captured, 'hello')).toBe(false)
+  })
+
+  it('returns true when stdout matches a regex marker', () => {
+    const {ctx, captured} = createCapturedCtx()
+    ctx.console.log('hello world')
+    expect(expectCapturedToInclude(captured, /^hello/)).toBe(true)
+  })
+
+  it('returns false when stdout does not match a regex marker', () => {
+    const {ctx, captured} = createCapturedCtx()
+    ctx.console.log('hello world')
+    expect(expectCapturedToInclude(captured, /^world/)).toBe(false)
+  })
+})

package/src/__test__/mcp-ctx-fixture.ts

@@ -0,0 +1,104 @@
+import {format} from 'node:util'
+
+export type {ActionCtx} from '../lib/action-ctx'
+
+/**
+ * Captured output from a `createCapturedCtx()` invocation.
+ */
+export interface CapturedOutput {
+  stdout: string[]
+  stderr: string[]
+  exit: {code: number} | null
+}
+
+/**
+ * Error thrown by `ctx.process.exit()` in the mock context.
+ * Mirrors the `GokeProcessExit` pattern from goke — exit always throws
+ * so action code cannot silently swallow it.
+ */
+export class MockProcessExit extends Error {
+  readonly code: number
+
+  constructor(code: number) {
+    super(`MockProcessExit: process.exit(${code})`)
+    this.name = 'MockProcessExit'
+    this.code = code
+  }
+}
+
+/**
+ * Minimal surface of `GokeExecutionContext` that the capture fixture provides.
+ * Matches `ctx.console.{log,error}`, `ctx.process.{stdout,stderr}.write`,
+ * and `ctx.process.exit` — the same shape produced by
+ * `createCallToolExecutionContext` in `@goke/mcp`.
+ */
+export interface CapturedCtx {
+  console: {
+    log: (...args: unknown[]) => void
+    error: (...args: unknown[]) => void
+  }
+  process: {
+    stdout: {write: (chunk: string | Uint8Array) => void}
+    stderr: {write: (chunk: string | Uint8Array) => void}
+    exit: (code: number) => never
+  }
+}
+
+function decodeChunk(chunk: string | Uint8Array): string {
+  if (typeof chunk === 'string') return chunk
+  return new TextDecoder().decode(chunk)
+}
+
+/**
+ * Create a fresh mock `GokeExecutionContext` with output capture.
+ *
+ * Each call returns an independent `{ctx, captured}` pair — no shared state.
+ * Use one call per test to keep tests isolated.
+ */
+export function createCapturedCtx(): {ctx: CapturedCtx; captured: CapturedOutput} {
+  const captured: CapturedOutput = {
+    stdout: [],
+    stderr: [],
+    exit: null,
+  }
+
+  const ctx: CapturedCtx = {
+    console: {
+      log(...args: unknown[]) {
+        captured.stdout.push(format(...args))
+      },
+      error(...args: unknown[]) {
+        captured.stderr.push(format(...args))
+      },
+    },
+    process: {
+      stdout: {
+        write(chunk: string | Uint8Array) {
+          captured.stdout.push(decodeChunk(chunk))
+        },
+      },
+      stderr: {
+        write(chunk: string | Uint8Array) {
+          captured.stderr.push(decodeChunk(chunk))
+        },
+      },
+      exit(code: number): never {
+        captured.exit = {code}
+        throw new MockProcessExit(code)
+      },
+    },
+  }
+
+  return {ctx, captured}
+}
+
+/**
+ * Returns `true` when the concatenated stdout contains `marker`.
+ *
+ * Composable — does not throw. Use with `expect(...).toBe(true)`.
+ */
+export function expectCapturedToInclude(captured: CapturedOutput, marker: string | RegExp): boolean {
+  const text = captured.stdout.join('')
+  if (typeof marker === 'string') return text.includes(marker)
+  return marker.test(text)
+}

package/src/commands/cliproxy/config.test.ts

@@ -1,10 +1,36 @@
-import {chmodSync, existsSync, statSync} from 'node:fs'
+import {existsSync, statSync} from 'node:fs'
 import {afterEach, beforeEach, describe, expect, it} from 'bun:test'
 
-import {buildSetRequest, formatConfigAsColumns, parseBoolean, parseNumber, resolveManagementKey} from './config'
+import {createCapturedCtx, expectCapturedToInclude} from '../../__test__/mcp-ctx-fixture'
+import {
+  buildSetRequest,
+  cliproxyConfigGetAction,
+  cliproxyConfigSetAction,
+  formatConfigAsColumns,
+  parseBoolean,
+  parseNumber,
+  resolveManagementKey,
+} from './config'
 import {toStringArray} from './keys'
 import {requireSshAuthSock, resolveHost} from './login'
 
+const originalFetch = globalThis.fetch
+
+type FetchReplacement = (url: string, init?: RequestInit) => Promise<Response>
+
+function createFetchImplementation(handler: FetchReplacement): typeof fetch {
+  return Object.assign(
+    (input: string | URL | Request, init?: RequestInit) => {
+      if (typeof input !== 'string') {
+        throw new TypeError(`Unexpected non-string fetch input: ${String(input)}`)
+      }
+
+      return handler(input, init)
+    },
+    {preconnect: originalFetch.preconnect},
+  )
+}
+
 describe('cliproxy config helpers', () => {
   describe('parseBoolean', () => {
     it('parses true values case-insensitively', () => {
@@ -100,95 +126,6 @@ describe('cliproxy config helpers', () => {
       expect(() => resolveManagementKey()).toThrow()
     })
   })
-
-  describe('config get --output', () => {
-    it('writes config JSON to file with 0600 permissions', async () => {
-      const testFile = '/tmp/test-config-output.json'
-      const mockConfig = {debug: true, 'api-keys': ['key1', 'key2']}
-
-      const originalFetch = globalThis.fetch as typeof fetch
-      ;(globalThis.fetch as unknown) = async () => {
-        return new Response(JSON.stringify(mockConfig), {status: 200})
-      }
-
-      try {
-        const baseUrl = 'https://cliproxy.example.com'
-        const managementKey = 'test-key'
-        const endpoint = `${baseUrl}/v0/management/config`
-        const response = await fetch(endpoint, {
-          method: 'GET',
-          headers: new Headers({
-            'x-management-key': managementKey,
-            'content-type': 'application/json',
-          }),
-        })
-        const payload = await response.json()
-        const jsonOutput = JSON.stringify(payload, null, 2)
-
-        await Bun.write(testFile, jsonOutput)
-        chmodSync(testFile, 0o600)
-        const {mode} = statSync(testFile)
-        const permissions = mode & 0o777
-
-        expect(existsSync(testFile)).toBe(true)
-        expect(permissions).toBe(0o600)
-
-        const content = await Bun.file(testFile).text()
-        expect(JSON.parse(content)).toEqual(mockConfig)
-      } finally {
-        ;(globalThis.fetch as unknown) = originalFetch
-        if (existsSync(testFile)) {
-          const fs = await import('node:fs/promises')
-          await fs.unlink(testFile).catch(() => {})
-        }
-      }
-    })
-
-    it('prints API key warning to stderr when writing to stdout', async () => {
-      const mockConfig = {debug: true, 'api-keys': ['secret-key']}
-      const stderrLines: string[] = []
-      const stdoutLines: string[] = []
-
-      const originalError = console.error
-      const originalLog = console.log
-      console.error = (...args: unknown[]) => {
-        stderrLines.push(String(args[0]))
-      }
-      console.log = (...args: unknown[]) => {
-        stdoutLines.push(String(args[0]))
-      }
-
-      const originalFetch = globalThis.fetch as typeof fetch
-      ;(globalThis.fetch as unknown) = async () => {
-        return new Response(JSON.stringify(mockConfig), {status: 200})
-      }
-
-      try {
-        const baseUrl = 'https://cliproxy.example.com'
-        const managementKey = 'test-key'
-        const endpoint = `${baseUrl}/v0/management/config`
-        const response = await fetch(endpoint, {
-          method: 'GET',
-          headers: new Headers({
-            'x-management-key': managementKey,
-            'content-type': 'application/json',
-          }),
-        })
-        const payload = await response.json()
-        const jsonOutput = JSON.stringify(payload, null, 2)
-
-        console.error('⚠️  Output may contain API keys — avoid logging or storing in shared locations')
-        console.log(jsonOutput)
-
-        expect(stderrLines.some(line => line.includes('API keys'))).toBe(true)
-        expect(stdoutLines.some(line => line.includes('debug'))).toBe(true)
-      } finally {
-        console.error = originalError
-        console.log = originalLog
-        ;(globalThis.fetch as unknown) = originalFetch
-      }
-    })
-  })
 })
 
 describe('formatConfigAsColumns', () => {
@@ -217,6 +154,239 @@ describe('formatConfigAsColumns', () => {
   })
 })
 
+describe('cliproxyConfigGetAction (Mode C, Tier-2 ctx capture)', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('Mode C: captures formatted config to ctx.stdout and returns config object', async () => {
+    const mockConfig = {debug: true, 'request-retry': 3}
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(mockConfig), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    const result = await cliproxyConfigGetAction({url: 'https://cliproxy.example.com', key: 'mgmt-key'}, ctx)
+
+    // Tier-2: stdout contains formatted config
+    expect(expectCapturedToInclude(captured, 'debug')).toBe(true)
+    expect(expectCapturedToInclude(captured, 'request-retry')).toBe(true)
+
+    // Mode C: action returns the config object
+    expect(result).toEqual(mockConfig)
+  })
+
+  it('Mode C: security warning goes to ctx.stderr', async () => {
+    const mockConfig = {debug: false}
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(mockConfig), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    await cliproxyConfigGetAction({url: 'https://cliproxy.example.com', key: 'mgmt-key'}, ctx)
+
+    const stderrText = captured.stderr.join('')
+    expect(stderrText).toContain('API keys')
+  })
+
+  it('Mode C: --json flag outputs raw JSON to ctx.stdout', async () => {
+    const mockConfig = {debug: true}
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(mockConfig), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    const result = await cliproxyConfigGetAction(
+      {url: 'https://cliproxy.example.com', key: 'mgmt-key', json: true},
+      ctx,
+    )
+
+    const stdoutText = captured.stdout.join('')
+    expect(JSON.parse(stdoutText)).toEqual(mockConfig)
+    expect(result).toEqual(mockConfig)
+  })
+
+  it('Mode C: --output writes file and prints confirmation to ctx.stdout', async () => {
+    const testFile = '/tmp/test-cliproxy-config-get-action.json'
+    const mockConfig = {debug: true, 'api-keys': ['key1', 'key2']}
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(mockConfig), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    try {
+      const result = await cliproxyConfigGetAction(
+        {url: 'https://cliproxy.example.com', key: 'mgmt-key', output: testFile},
+        ctx,
+      )
+
+      expect(existsSync(testFile)).toBe(true)
+      const {mode} = statSync(testFile)
+      expect(mode & 0o777).toBe(0o600)
+      expect(JSON.parse(await Bun.file(testFile).text())).toEqual(mockConfig)
+      expect(expectCapturedToInclude(captured, '✓ Config written to')).toBe(true)
+      expect(result).toEqual(mockConfig)
+    } finally {
+      if (existsSync(testFile)) {
+        const fs = await import('node:fs/promises')
+        await fs.unlink(testFile).catch(() => {})
+      }
+    }
+  })
+})
+
+describe('cliproxyConfigSetAction (Mode A, two positional args, Tier-2 ctx capture)', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('Mode A: captures PUT response to ctx.stdout', async () => {
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify({value: true}), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    await cliproxyConfigSetAction('debug', 'true', {url: 'https://cliproxy.example.com', key: 'mgmt-key'}, ctx)
+
+    expect(expectCapturedToInclude(captured, 'value')).toBe(true)
+    expect(expectCapturedToInclude(captured, 'true')).toBe(true)
+  })
+
+  it('Mode A: routes unsupported field error through ctx.console.error + exit(1)', async () => {
+    const {ctx, captured} = createCapturedCtx()
+    await expect(
+      cliproxyConfigSetAction('unsupported-field', 'val', {url: 'https://cliproxy.example.com', key: 'mgmt-key'}, ctx),
+    ).rejects.toMatchObject({name: 'MockProcessExit', code: 1})
+    expect(captured.stderr.join('')).toContain('not a supported mutable field')
+    expect(captured.exit).toEqual({code: 1})
+  })
+})
+
+describe('cliproxyConfigGetAction (Tier-2 failure-path parity)', () => {
+  const originalManagementKey = process.env.CLIPROXY_MANAGEMENT_KEY
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    if (originalManagementKey === undefined) {
+      delete process.env.CLIPROXY_MANAGEMENT_KEY
+    } else {
+      process.env.CLIPROXY_MANAGEMENT_KEY = originalManagementKey
+    }
+  })
+
+  it('Tier-2: missing CLIPROXY_MANAGEMENT_KEY routes to ctx.console.error + exit(1)', async () => {
+    delete process.env.CLIPROXY_MANAGEMENT_KEY
+
+    const {ctx, captured} = createCapturedCtx()
+    await expect(cliproxyConfigGetAction({url: 'https://cliproxy.example.com'}, ctx)).rejects.toMatchObject({
+      name: 'MockProcessExit',
+      code: 1,
+    })
+    expect(captured.stderr.join('')).toContain('Management API key')
+    expect(captured.exit).toEqual({code: 1})
+  })
+
+  it('Tier-2: HTTP 500 response routes to ctx.console.error + exit(1)', async () => {
+    globalThis.fetch = createFetchImplementation(async () => new Response('server error', {status: 500}))
+
+    const {ctx, captured} = createCapturedCtx()
+    await expect(
+      cliproxyConfigGetAction({url: 'https://cliproxy.example.com', key: 'mgmt-key'}, ctx),
+    ).rejects.toMatchObject({
+      name: 'MockProcessExit',
+      code: 1,
+    })
+    expect(captured.stderr.join('')).toContain('HTTP 500')
+    expect(captured.exit).toEqual({code: 1})
+  })
+
+  it('Tier-2: --output write failure routes to ctx.console.error + exit(1)', async () => {
+    const mockConfig = {debug: true}
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(mockConfig), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    // Use a path that cannot be written (directory as file path)
+    const {ctx, captured} = createCapturedCtx()
+    await expect(
+      cliproxyConfigGetAction(
+        {url: 'https://cliproxy.example.com', key: 'mgmt-key', output: '/dev/null/cannot-write'},
+        ctx,
+      ),
+    ).rejects.toMatchObject({
+      name: 'MockProcessExit',
+      code: 1,
+    })
+    expect(captured.stderr.join('')).toContain('Failed to write config')
+    expect(captured.exit).toEqual({code: 1})
+  })
+})
+
+describe('cliproxyConfigSetAction (Tier-2 failure-path parity)', () => {
+  const originalManagementKey = process.env.CLIPROXY_MANAGEMENT_KEY
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    if (originalManagementKey === undefined) {
+      delete process.env.CLIPROXY_MANAGEMENT_KEY
+    } else {
+      process.env.CLIPROXY_MANAGEMENT_KEY = originalManagementKey
+    }
+  })
+
+  it('Tier-2: missing CLIPROXY_MANAGEMENT_KEY routes to ctx.console.error + exit(1)', async () => {
+    delete process.env.CLIPROXY_MANAGEMENT_KEY
+
+    const {ctx, captured} = createCapturedCtx()
+    await expect(
+      cliproxyConfigSetAction('debug', 'true', {url: 'https://cliproxy.example.com'}, ctx),
+    ).rejects.toMatchObject({
+      name: 'MockProcessExit',
+      code: 1,
+    })
+    expect(captured.stderr.join('')).toContain('Management API key')
+    expect(captured.exit).toEqual({code: 1})
+  })
+
+  it('Tier-2: HTTP 500 response routes to ctx.console.error + exit(1)', async () => {
+    globalThis.fetch = createFetchImplementation(async () => new Response('server error', {status: 500}))
+
+    const {ctx, captured} = createCapturedCtx()
+    await expect(
+      cliproxyConfigSetAction('debug', 'true', {url: 'https://cliproxy.example.com', key: 'mgmt-key'}, ctx),
+    ).rejects.toMatchObject({
+      name: 'MockProcessExit',
+      code: 1,
+    })
+    expect(captured.stderr.join('')).toContain('HTTP 500')
+    expect(captured.exit).toEqual({code: 1})
+  })
+})
+
 describe('cliproxy keys helpers', () => {
   describe('toStringArray', () => {
     it('returns string arrays filtered to strings only', () => {