@marcusrbrown/infra 0.9.4 → 0.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marcusrbrown/infra",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "description": "Infrastructure management CLI — deploy automation, health checks, and MCP bridge",
   "keywords": [
     "infra",

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

@@ -239,6 +239,107 @@ describe('cliproxy login', () => {
     })
   })
 
+  describe('host forwarding into ssh argv', () => {
+    it('forwards resolved host from CLIPROXY_DOMAIN env var into ssh argv', async () => {
+      const {cliproxyLoginAction} = await import('./login')
+      const {spawnFn, calls} = makeSpawnOk(0)
+      setValidEnv()
+      process.env.CLIPROXY_DOMAIN = 'env-host.example.com'
+
+      await cliproxyLoginAction('claude', {}, spawnFn)
+
+      expect(calls).toHaveLength(1)
+      expect(calls[0]!.cmd).toContain('root@env-host.example.com')
+    })
+
+    it('forwards resolved host from --host option into ssh argv', async () => {
+      const {cliproxyLoginAction} = await import('./login')
+      const {spawnFn, calls} = makeSpawnOk(0)
+      setValidEnv()
+      delete process.env.CLIPROXY_DOMAIN
+
+      await cliproxyLoginAction('claude', {host: 'flag-host.example.com'}, spawnFn)
+
+      expect(calls).toHaveLength(1)
+      expect(calls[0]!.cmd).toContain('root@flag-host.example.com')
+    })
+  })
+
+  describe('non-zero exit propagation', () => {
+    it('throws with exit code in message when remote ssh exits non-zero', async () => {
+      const {cliproxyLoginAction} = await import('./login')
+      const {spawnFn, calls} = makeSpawnOk(17)
+      setValidEnv()
+
+      await expect(cliproxyLoginAction('claude', {}, spawnFn)).rejects.toThrow(
+        'Remote login command failed with exit code 17',
+      )
+      expect(calls).toHaveLength(1)
+    })
+  })
+
+  describe('ssh spawn contract', () => {
+    it('happy path — claude: spawn argv and options match ssh boundary contract', async () => {
+      const {cliproxyLoginAction} = await import('./login')
+      const {spawnFn, calls} = makeSpawnOk(0)
+      setValidEnv()
+      process.env.SSH_AUTH_SOCK = '/tmp/contract-test.sock'
+      const capturedPath = process.env.PATH!
+      const capturedHome = process.env.HOME!
+
+      await cliproxyLoginAction('claude', {}, spawnFn)
+
+      expect(calls).toHaveLength(1)
+      const {cmd, opts} = calls[0]!
+      const spawnOpts = opts as Parameters<SpawnFn>[1]
+
+      // SSH flags
+      expect(cmd).toContain('-tt')
+      expect(cmd).toContain('BatchMode=yes')
+      expect(cmd).toContain('ConnectTimeout=10')
+
+      // stdio inheritance
+      expect(spawnOpts.stdin).toBe('inherit')
+      expect(spawnOpts.stdout).toBe('inherit')
+      expect(spawnOpts.stderr).toBe('inherit')
+
+      // forwarded env vars
+      expect(spawnOpts.env.PATH).toBe(capturedPath)
+      expect(spawnOpts.env.HOME).toBe(capturedHome)
+      expect(spawnOpts.env.SSH_AUTH_SOCK).toBe('/tmp/contract-test.sock')
+    })
+
+    it('happy path — codex: spawn argv and options match ssh boundary contract', async () => {
+      const {cliproxyLoginAction} = await import('./login')
+      const {spawnFn, calls} = makeSpawnOk(0)
+      setValidEnv()
+      process.env.SSH_AUTH_SOCK = '/tmp/contract-test.sock'
+      const capturedPath = process.env.PATH!
+      const capturedHome = process.env.HOME!
+
+      await cliproxyLoginAction('codex', {}, spawnFn)
+
+      expect(calls).toHaveLength(1)
+      const {cmd, opts} = calls[0]!
+      const spawnOpts = opts as Parameters<SpawnFn>[1]
+
+      // SSH flags
+      expect(cmd).toContain('-tt')
+      expect(cmd).toContain('BatchMode=yes')
+      expect(cmd).toContain('ConnectTimeout=10')
+
+      // stdio inheritance
+      expect(spawnOpts.stdin).toBe('inherit')
+      expect(spawnOpts.stdout).toBe('inherit')
+      expect(spawnOpts.stderr).toBe('inherit')
+
+      // forwarded env vars
+      expect(spawnOpts.env.PATH).toBe(capturedPath)
+      expect(spawnOpts.env.HOME).toBe(capturedHome)
+      expect(spawnOpts.env.SSH_AUTH_SOCK).toBe('/tmp/contract-test.sock')
+    })
+  })
+
   describe('anti-phishing notice', () => {
     let logLines: string[]
     let originalLog: typeof console.log

package/src/commands/cliproxy/setup/preview.test.ts

@@ -37,7 +37,7 @@ describe('formatDryRunPreview', () => {
     expect(preview).toContain('Planned secrets:')
     expect(preview).toContain('OPENCODE_AUTH_JSON')
     expect(preview).toContain('OPENCODE_CONFIG')
-    expect(preview).toContain('OMO_PROVIDERS')
+    expect(preview).not.toContain('OMO_PROVIDERS')
   })
 
   it('renders planned variables', () => {

package/src/commands/cliproxy/setup/templates.test.ts

@@ -123,7 +123,6 @@ describe('getHarnessTemplate', () => {
     expect(template.secrets.map((entry: SecretAssignment) => entry.name)).toEqual([
       'OPENCODE_AUTH_JSON',
       'OPENCODE_CONFIG',
-      'OMO_PROVIDERS',
     ])
     expect(template.variables.map((entry: VariableAssignment) => entry.name)).toEqual(['FRO_BOT_MODEL'])
   })
@@ -135,11 +134,11 @@ describe('getHarnessTemplate', () => {
     expect(modelEntry?.value).toMatch(/^anthropic\//)
   })
 
-  it('uses the expected OMO_PROVIDERS default value', () => {
+  it('does not include an OMO_PROVIDERS secret', () => {
     const template = getHarnessTemplate('opencode', {keyValue: 'sk-test'})
-    const providersEntry = template.secrets.find((entry: SecretAssignment) => entry.name === 'OMO_PROVIDERS')
+    const secretNames = template.secrets.map((entry: SecretAssignment) => entry.name)
 
-    expect(providersEntry?.value).toBe('claude-max20')
+    expect(secretNames).not.toContain('OMO_PROVIDERS')
   })
 
   it('writes an OPENCODE_CONFIG baseURL with the /v1 suffix', () => {
@@ -183,11 +182,11 @@ describe('getHarnessTemplate provider-aware', () => {
       expect(configEntry?.value).toBe(ANTHROPIC_ONLY_CONFIG)
     })
 
-    it('no providers/model args → OMO_PROVIDERS is claude-max20', () => {
+    it('no providers/model args → OMO_PROVIDERS is not emitted', () => {
       const template = getHarnessTemplate('opencode', {keyValue: 'test-key'})
-      const entry = template.secrets.find((e: SecretAssignment) => e.name === 'OMO_PROVIDERS')
+      const secretNames = template.secrets.map((e: SecretAssignment) => e.name)
 
-      expect(entry?.value).toBe('claude-max20')
+      expect(secretNames).not.toContain('OMO_PROVIDERS')
     })
 
     it('no providers/model args → FRO_BOT_MODEL is anthropic/claude-sonnet-4-6', () => {
@@ -234,15 +233,15 @@ describe('getHarnessTemplate provider-aware', () => {
       expect(configEntry?.value).toBe('{"provider":{"openai":{"options":{"baseURL":"https://cliproxy.fro.bot/v1"}}}}')
     })
 
-    it("providers: ['openai'], model: 'openai/gpt-5.4-mini' → OMO_PROVIDERS is openai", () => {
+    it("providers: ['openai'], model: 'openai/gpt-5.4-mini' → OMO_PROVIDERS is not emitted", () => {
       const template = getHarnessTemplate('opencode', {
         keyValue: 'sk-openai-key',
         providers: ['openai'],
         model: 'openai/gpt-5.4-mini',
       })
-      const entry = template.secrets.find((e: SecretAssignment) => e.name === 'OMO_PROVIDERS')
+      const secretNames = template.secrets.map((e: SecretAssignment) => e.name)
 
-      expect(entry?.value).toBe('openai')
+      expect(secretNames).not.toContain('OMO_PROVIDERS')
     })
 
     it("providers: ['openai'], model: 'openai/gpt-5.4-mini' → FRO_BOT_MODEL is openai/gpt-5.4-mini", () => {
@@ -294,15 +293,15 @@ describe('getHarnessTemplate provider-aware', () => {
       )
     })
 
-    it("providers: ['anthropic', 'openai'] → OMO_PROVIDERS is claude-max20,openai", () => {
+    it("providers: ['anthropic', 'openai'] → OMO_PROVIDERS is not emitted", () => {
       const template = getHarnessTemplate('opencode', {
         keyValue: 'sk-dual',
         providers: ['anthropic', 'openai'],
         model: 'openai/gpt-5.4-mini',
       })
-      const entry = template.secrets.find((e: SecretAssignment) => e.name === 'OMO_PROVIDERS')
+      const secretNames = template.secrets.map((e: SecretAssignment) => e.name)
 
-      expect(entry?.value).toBe('claude-max20,openai')
+      expect(secretNames).not.toContain('OMO_PROVIDERS')
     })
 
     it("providers: ['anthropic', 'openai'] → FRO_BOT_MODEL is the supplied model", () => {

package/src/commands/cliproxy/setup/templates.ts

@@ -25,13 +25,6 @@ export interface HarnessTemplate {
 
 const DEFAULT_CLIPROXY_URL = 'https://cliproxy.fro.bot'
 
-// OMO_PROVIDERS token map — template/harness concern, not a provider concern.
-// Keyed by ProviderId but lives here because it drives harness template construction.
-const OMO_TOKEN: Record<ProviderId, string> = {
-  anthropic: 'claude-max20',
-  openai: 'openai',
-}
-
 export function stripTrailingSlash(value: string): string {
   return value.endsWith('/') ? value.slice(0, -1) : value
 }
@@ -78,8 +71,6 @@ export function getHarnessTemplate(
       providerConfig[p] = {options: {baseURL: `${baseUrl}/v1`}}
     }
 
-    const omoProviders = providers.map(p => OMO_TOKEN[p]).join(',')
-
     return {
       secrets: [
         {
@@ -90,10 +81,6 @@ export function getHarnessTemplate(
           name: 'OPENCODE_CONFIG',
           value: JSON.stringify({provider: providerConfig}),
         },
-        {
-          name: 'OMO_PROVIDERS',
-          value: omoProviders,
-        },
       ],
       variables: [
         {

package/src/commands/cliproxy/setup/workflow-analyzer.test.ts

@@ -230,14 +230,36 @@ describe('cliproxy setup helpers', () => {
       expect(Object.keys(dualResult)).toEqual(['kind', 'stepsWithGaps'])
     })
 
-    it('REQUIRED_OPENCODE_INPUTS covers exactly auth-json, opencode-config, omo-providers, model (no enable-omo)', () => {
-      // Infer the required inputs from fixture-based testing: a workflow with exactly
-      // these four inputs and no others (besides github-token and prompt) passes with zero gaps.
-      const result = analyzeFroBotWorkflow(WORKFLOW_WITH_OPENAI_MODEL)
+    it('REQUIRED_OPENCODE_INPUTS covers exactly auth-json, opencode-config, model (no omo-providers, no enable-omo)', () => {
+      // A workflow that wires auth-json, opencode-config, model (but NOT omo-providers) must
+      // pass with zero gaps — omo-providers is vestigial and must not be required.
+      const workflowWithoutOmo = `      - uses: fro-bot/agent@abc123
+        with:
+          github-token: \${{ secrets.FRO_BOT_PAT }}
+          auth-json: \${{ secrets.OPENCODE_AUTH_JSON }}
+          model: \${{ vars.FRO_BOT_MODEL }}
+          opencode-config: \${{ secrets.OPENCODE_CONFIG }}
+          prompt: \${{ env.PROMPT }}
+`
+      const result = analyzeFroBotWorkflow(workflowWithoutOmo)
+
+      expect(result.kind).toBe('analyzed')
+      if (result.kind !== 'analyzed') throw new Error('unreachable')
+      // Zero gaps confirms omo-providers is NOT required.
+      expect(result.stepsWithGaps).toEqual([])
+    })
+
+    it('a workflow missing only omo-providers (but with auth-json, opencode-config, model) is not flagged', () => {
+      const workflowWithoutOmo = `      - uses: fro-bot/agent@abc123
+        with:
+          auth-json: \${{ secrets.OPENCODE_AUTH_JSON }}
+          opencode-config: \${{ secrets.OPENCODE_CONFIG }}
+          model: \${{ vars.FRO_BOT_MODEL }}
+`
+      const result = analyzeFroBotWorkflow(workflowWithoutOmo)
 
       expect(result.kind).toBe('analyzed')
       if (result.kind !== 'analyzed') throw new Error('unreachable')
-      // Zero gaps confirms the four inputs in the fixture are sufficient — enable-omo is NOT required.
       expect(result.stepsWithGaps).toEqual([])
     })
   })

package/src/commands/cliproxy/setup/workflow-analyzer.ts

@@ -23,7 +23,7 @@ export type FroBotWorkflowCheck =
 // For proxy-routed providers configured via OPENCODE_CONFIG.provider.<name>.options.baseURL,
 // the fro-bot/agent action honors auth.json directly (regardless of oMo state).
 // Source: fro-bot/agent@v0.44.3+ action.yaml lines 99-104; verified by librarian 2026-05-25.
-const REQUIRED_OPENCODE_INPUTS = ['auth-json', 'opencode-config', 'omo-providers', 'model'] as const
+const REQUIRED_OPENCODE_INPUTS = ['auth-json', 'opencode-config', 'model'] as const
 type RequiredOpencodeInput = (typeof REQUIRED_OPENCODE_INPUTS)[number]
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
@@ -129,7 +129,6 @@ export function formatWorkflowSnippet(missingInputs: readonly string[]): string
   const inputMap = {
     'auth-json': 'auth-json: ${{ secrets.OPENCODE_AUTH_JSON }}',
     'opencode-config': 'opencode-config: ${{ secrets.OPENCODE_CONFIG }}',
-    'omo-providers': 'omo-providers: ${{ secrets.OMO_PROVIDERS }}',
     model: 'model: ${{ vars.FRO_BOT_MODEL }}',
   } satisfies Record<RequiredOpencodeInput, string>
   /* eslint-enable no-template-curly-in-string */

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

@@ -2038,7 +2038,7 @@ describe('post-write readback verification', () => {
 
   it('happy path: readback returns all written names → no new warning emitted', async () => {
     // Pre-write list is empty; post-write readback returns all written names
-    // The opencode harness writes: OPENCODE_AUTH_JSON, OPENCODE_CONFIG, OMO_PROVIDERS (secrets)
+    // The opencode harness writes: OPENCODE_AUTH_JSON, OPENCODE_CONFIG (secrets)
     // and FRO_BOT_MODEL (variable)
     let callCount = 0
     const {deps} = makeDeps(async (_repo, kind) => {
@@ -2048,7 +2048,7 @@ describe('post-write readback verification', () => {
         return []
       }
       // Post-write readback: return all written names
-      if (kind === 'secret') return ['OPENCODE_AUTH_JSON', 'OPENCODE_CONFIG', 'OMO_PROVIDERS']
+      if (kind === 'secret') return ['OPENCODE_AUTH_JSON', 'OPENCODE_CONFIG']
       return ['FRO_BOT_MODEL']
     })
 
@@ -2068,7 +2068,7 @@ describe('post-write readback verification', () => {
       callCount++
       if (callCount <= 2) return []
       // Post-write: secret readback missing OPENCODE_AUTH_JSON
-      if (kind === 'secret') return ['OPENCODE_CONFIG', 'OMO_PROVIDERS']
+      if (kind === 'secret') return ['OPENCODE_CONFIG']
       return ['FRO_BOT_MODEL']
     })
 
@@ -2088,7 +2088,7 @@ describe('post-write readback verification', () => {
     const {deps} = makeDeps(async (_repo, kind) => {
       callCount++
       if (callCount <= 2) return []
-      if (kind === 'secret') return ['OPENCODE_AUTH_JSON', 'OPENCODE_CONFIG', 'OMO_PROVIDERS']
+      if (kind === 'secret') return ['OPENCODE_AUTH_JSON', 'OPENCODE_CONFIG']
       // Variable readback missing FRO_BOT_MODEL
       return []
     })
@@ -2102,12 +2102,12 @@ describe('post-write readback verification', () => {
   })
 
   it('partial visibility: readback shows some but not all written names → warning lists exactly the absent names', async () => {
-    // Post-write: OPENCODE_CONFIG and OMO_PROVIDERS present, OPENCODE_AUTH_JSON absent
+    // Post-write: OPENCODE_CONFIG present, OPENCODE_AUTH_JSON absent
     let callCount = 0
     const {deps} = makeDeps(async (_repo, kind) => {
       callCount++
       if (callCount <= 2) return []
-      if (kind === 'secret') return ['OPENCODE_CONFIG', 'OMO_PROVIDERS'] // OPENCODE_AUTH_JSON absent
+      if (kind === 'secret') return ['OPENCODE_CONFIG'] // OPENCODE_AUTH_JSON absent
       return ['FRO_BOT_MODEL']
     })
 
@@ -2117,9 +2117,8 @@ describe('post-write readback verification', () => {
     expect(mismatchWarnings.length).toBeGreaterThan(0)
     // Must name OPENCODE_AUTH_JSON (absent)
     expect(mismatchWarnings.some(m => m.includes('OPENCODE_AUTH_JSON'))).toBe(true)
-    // Must NOT name OPENCODE_CONFIG or OMO_PROVIDERS (they ARE present)
+    // Must NOT name OPENCODE_CONFIG (it IS present)
     expect(mismatchWarnings.some(m => m.includes('OPENCODE_CONFIG'))).toBe(false)
-    expect(mismatchWarnings.some(m => m.includes('OMO_PROVIDERS'))).toBe(false)
   })
 
   it('cannot verify: listExistingGhNames throws on post-write call → softer warning, command does NOT throw, rollback NOT fired', async () => {
@@ -2268,7 +2267,7 @@ describe('post-write readback verification', () => {
         return []
       }
       // Post-write readback: all names present
-      if (kind === 'secret') return ['OPENCODE_AUTH_JSON', 'OPENCODE_CONFIG', 'OMO_PROVIDERS']
+      if (kind === 'secret') return ['OPENCODE_AUTH_JSON', 'OPENCODE_CONFIG']
       return ['FRO_BOT_MODEL']
     })
 
@@ -2338,7 +2337,7 @@ describe('non-interactive overwrite warning concurrency caveat', () => {
   it('--force overwrite with a collision present → warning carries the last-write-wins concurrency caveat', async () => {
     // OPENCODE_AUTH_JSON already exists → collision on the opencode secret set → overwrite warning fires.
     const deps = makeDeps(async (_repo, kind) => {
-      if (kind === 'secret') return ['OPENCODE_AUTH_JSON', 'OPENCODE_CONFIG', 'OMO_PROVIDERS']
+      if (kind === 'secret') return ['OPENCODE_AUTH_JSON', 'OPENCODE_CONFIG']
       return ['FRO_BOT_MODEL']
     })
 

package/src/commands/cliproxy/setup.ts

@@ -350,7 +350,7 @@ export async function buildNonInteractivePlan(
   // Check BEFORE verifyModelsAvailable to avoid a network call when the gate will reject anyway.
   if (requiresDestructiveProviderChangeConfirmation(providers) && !options.force) {
     throw new Error(
-      `Refusing destructive provider change on ${options.repo ?? ''} without --force. Selected providers ${providers.join(', ')} would overwrite existing GitHub secret values (OPENCODE_AUTH_JSON, OPENCODE_CONFIG, OMO_PROVIDERS, FRO_BOT_MODEL). Note: --force authorizes overwriting these GitHub secret values; it does NOT rotate the underlying CLIProxyAPI proxy bearer token (which is preserved byte-for-byte when --key is supplied).`,
+      `Refusing destructive provider change on ${options.repo ?? ''} without --force. Selected providers ${providers.join(', ')} would overwrite existing GitHub secret values (OPENCODE_AUTH_JSON, OPENCODE_CONFIG, FRO_BOT_MODEL). Note: --force authorizes overwriting these GitHub secret values; it does NOT rotate the underlying CLIProxyAPI proxy bearer token (which is preserved byte-for-byte when --key is supplied).`,
     )
   }
 

package/src/commands/mcp.test.ts

@@ -73,6 +73,14 @@ function buildTestCli(): ReturnType<typeof goke> {
   return cli
 }
 
+/** Extract all text block content from a CallToolResult, joined by newline. */
+function allText(result: CallToolResult): string {
+  return result.content
+    .filter((block): block is {type: 'text'; text: string} => block.type === 'text')
+    .map(block => block.text)
+    .join('\n')
+}
+
 // ─── Suite ────────────────────────────────────────────────────────────────────
 
 describe('mcp integration (Tier-1, in-process)', () => {
@@ -125,24 +133,46 @@ describe('mcp integration (Tier-1, in-process)', () => {
 
   // ── Mode B contract: gateway_backup ───────────────────────────────────────
   //
-  // gateway_backup tries to SSH to a real droplet, which is unreachable in CI.
-  // We assert the contract: the tool returns a non-empty CallToolResult.
-  // In CI the result will be an error CallToolResult (isError: true) because
-  // SSH fails — that's fine; the contract is that the MCP layer wraps the
-  // error and returns content rather than throwing.
-
-  test('gateway_backup returns a non-empty CallToolResult (Mode B contract)', async () => {
-    const rawResult = await client.callTool(
-      {
-        name: 'gateway_backup',
-        arguments: {},
-      },
-      CallToolResultSchema,
-    )
-    // Parse through the schema to get a properly typed result.
-    // The tool must return at least one content block (even on SSH failure).
-    const result: CallToolResult = CallToolResultSchema.parse(rawResult)
-    expect(result.content.length).toBeGreaterThan(0)
+  // gateway_backup reads GATEWAY_HOST before attempting any SSH call.
+  // When GATEWAY_HOST is unset the action exits synchronously with a
+  // well-known error message — no network contact is made.
+  // The MCP layer must wrap that failure as an error CallToolResult
+  // (isError: true) rather than throwing, and the content must contain
+  // the exact error message from gatewayBackupAction so we catch contract
+  // regressions if the message ever changes.
+
+  test('gateway_backup wraps missing-GATEWAY_HOST as an error CallToolResult with the known message', async () => {
+    const originalHost = process.env.GATEWAY_HOST
+
+    try {
+      // Delete GATEWAY_HOST to trigger the fast synchronous error path inside
+      // gatewayBackupAction — no SSH or network call is made.
+      delete process.env.GATEWAY_HOST
+
+      const rawResult = await client.callTool(
+        {
+          name: 'gateway_backup',
+          arguments: {},
+        },
+        CallToolResultSchema,
+      )
+
+      const result: CallToolResult = CallToolResultSchema.parse(rawResult)
+
+      // The MCP layer must surface the error as a content block, not a thrown exception.
+      expect(result.isError).toBe(true)
+      expect(result.content.length).toBeGreaterThan(0)
+
+      // The content must carry the exact contract-bearing error string from
+      // gatewayBackupAction. This assertion fails if the error message changes.
+      expect(allText(result)).toContain('Gateway host not set. Export GATEWAY_HOST before running backup.')
+    } finally {
+      if (originalHost === undefined) {
+        delete process.env.GATEWAY_HOST
+      } else {
+        process.env.GATEWAY_HOST = originalHost
+      }
+    }
   })
 
   // ── Mode C contract: cliproxy_keys_list ───────────────────────────────────
@@ -177,13 +207,10 @@ describe('mcp integration (Tier-1, in-process)', () => {
       // Mode C contract: at least 2 content blocks (stdout text + structured return)
       expect(result.content.length).toBeGreaterThanOrEqual(2)
 
-      const allText = result.content
-        .filter((block): block is {type: 'text'; text: string} => block.type === 'text')
-        .map(block => block.text)
-        .join('\n')
+      const text = allText(result)
 
       // One block must contain the formatted stdout (key names printed by the action)
-      expect(allText).toContain('fro-bot-test1')
+      expect(text).toContain('fro-bot-test1')
 
       // One block must contain the stringified return value (JSON array of key names)
       const hasStructuredReturn = result.content.some(block => {
@@ -205,4 +232,177 @@ describe('mcp integration (Tier-1, in-process)', () => {
       }
     }
   })
+
+  // ── Positional-arg routing: cliproxy_keys_add ─────────────────────────────
+  //
+  // The MCP inputSchema for cliproxy_keys_add has a single required property
+  // `key` (derived from the command's positional `<key>` argument). This test
+  // proves that goke routes the MCP argument value through to the action's
+  // positional parameter (apiKeyToAdd) by asserting the key name appears in
+  // the action's output text.
+  //
+  // Verified inputSchema (empirical): { properties: { key: { type: "string",
+  //   description: "Management API key…" }, url: { type: "string" } },
+  //   required: ["key"] }
+
+  test('cliproxy_keys_add routes the positional key argument through MCP', async () => {
+    const originalFetch = globalThis.fetch
+    const originalKey = process.env.CLIPROXY_MANAGEMENT_KEY
+
+    try {
+      process.env.CLIPROXY_MANAGEMENT_KEY = 'test-management-key'
+
+      globalThis.fetch = (async (_url: string | URL | Request, _init?: RequestInit): Promise<Response> => {
+        const method = typeof _init?.method === 'string' ? _init.method.toUpperCase() : 'GET'
+        if (method === 'GET') {
+          // Return empty current key list so the new key is not already present
+          return new Response(JSON.stringify([]), {
+            status: 200,
+            headers: {'content-type': 'application/json'},
+          })
+        }
+
+        // PUT response — the action ignores the body and logs the new count
+        return new Response(JSON.stringify(['tier1-test-key']), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        })
+      }) as typeof fetch
+
+      const rawResult = await client.callTool(
+        {
+          name: 'cliproxy_keys_add',
+          // `key` is the positional <key> arg (the API key to add).
+          // Verified from listTools() inputSchema — required property.
+          arguments: {key: 'tier1-test-key'},
+        },
+        CallToolResultSchema,
+      )
+
+      const result: CallToolResult = CallToolResultSchema.parse(rawResult)
+
+      expect(result.isError).not.toBe(true)
+      // The action logs `Added key "tier1-test-key"` — presence proves the
+      // positional arg was correctly routed from the MCP call.
+      expect(allText(result)).toContain('tier1-test-key')
+    } finally {
+      globalThis.fetch = originalFetch
+      if (originalKey === undefined) {
+        delete process.env.CLIPROXY_MANAGEMENT_KEY
+      } else {
+        process.env.CLIPROXY_MANAGEMENT_KEY = originalKey
+      }
+    }
+  })
+
+  // ── Positional-arg routing: cliproxy_keys_remove ──────────────────────────
+  //
+  // The MCP inputSchema for cliproxy_keys_remove has a required property `key`
+  // (derived from the positional `<key>` argument). The action issues a DELETE
+  // request with `?value=<apiKeyToRemove>` and logs the response. The fetch mock
+  // echoes back the query-parameter value so we can assert it was routed correctly.
+  //
+  // Verified inputSchema (empirical): { properties: { key: { type: "string" },
+  //   url: { type: "string" } }, required: ["key"] }
+
+  test('cliproxy_keys_remove routes the positional key argument through MCP', async () => {
+    const originalFetch = globalThis.fetch
+    const originalKey = process.env.CLIPROXY_MANAGEMENT_KEY
+
+    try {
+      process.env.CLIPROXY_MANAGEMENT_KEY = 'test-management-key'
+
+      globalThis.fetch = (async (_url: string | URL | Request, _init?: RequestInit): Promise<Response> => {
+        // The action appends ?value=<apiKeyToRemove> — echo it back in the
+        // response body so the assertion can verify positional routing.
+        const urlStr = typeof _url === 'string' ? _url : _url instanceof URL ? _url.href : (_url as Request).url
+        const url = new URL(urlStr)
+        const removedKey = url.searchParams.get('value') ?? 'unknown'
+        return new Response(JSON.stringify({removed: removedKey}), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        })
+      }) as typeof fetch
+
+      const rawResult = await client.callTool(
+        {
+          name: 'cliproxy_keys_remove',
+          // `key` is the positional <key> arg (the API key to remove).
+          // Verified from listTools() inputSchema — required property.
+          arguments: {key: 'tier1-test-remove-key'},
+        },
+        CallToolResultSchema,
+      )
+
+      const result: CallToolResult = CallToolResultSchema.parse(rawResult)
+
+      expect(result.isError).not.toBe(true)
+      // The response includes the echoed ?value= param — proves the positional
+      // arg was routed to the DELETE URL query parameter.
+      expect(allText(result)).toContain('tier1-test-remove-key')
+    } finally {
+      globalThis.fetch = originalFetch
+      if (originalKey === undefined) {
+        delete process.env.CLIPROXY_MANAGEMENT_KEY
+      } else {
+        process.env.CLIPROXY_MANAGEMENT_KEY = originalKey
+      }
+    }
+  })
+
+  // ── Positional-arg routing: cliproxy_config_set ───────────────────────────
+  //
+  // The MCP inputSchema for cliproxy_config_set has two required properties:
+  // `field` and `value` (both positional). The action PUT-s `{value: <parsed>}`
+  // to the field-specific endpoint and logs the response JSON. Returning the
+  // value in the mock response lets us assert both positionals were routed.
+  //
+  // Verified inputSchema (empirical): { properties: { field: { type: "string",
+  //   description: "Positional argument field" }, value: { type: "string",
+  //   description: "Positional argument value" }, url: …, key: … },
+  //   required: ["field","value"] }
+
+  test('cliproxy_config_set routes both positional arguments (field and value) through MCP', async () => {
+    const originalFetch = globalThis.fetch
+    const originalKey = process.env.CLIPROXY_MANAGEMENT_KEY
+
+    try {
+      process.env.CLIPROXY_MANAGEMENT_KEY = 'test-management-key'
+
+      globalThis.fetch = (async (_url: string | URL | Request, _init?: RequestInit): Promise<Response> => {
+        // Echo back the parsed body so we can assert the value was routed.
+        // The action sends {value: <parsedValue>}. We return it as-is.
+        const body = _init?.body
+        const parsed: unknown = body ? JSON.parse(String(body)) : {}
+        return new Response(JSON.stringify(parsed), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        })
+      }) as typeof fetch
+
+      const rawResult = await client.callTool(
+        {
+          name: 'cliproxy_config_set',
+          // `field` and `value` are the positional args from `<field> <value>`.
+          // `proxy-url` is a string-type mutable field — no parsing needed.
+          arguments: {field: 'proxy-url', value: 'tier1-test-url'},
+        },
+        CallToolResultSchema,
+      )
+
+      const result: CallToolResult = CallToolResultSchema.parse(rawResult)
+
+      expect(result.isError).not.toBe(true)
+      // The response echoes back {value: "tier1-test-url"} — presence of the
+      // value proves positional routing worked end-to-end.
+      expect(allText(result)).toContain('tier1-test-url')
+    } finally {
+      globalThis.fetch = originalFetch
+      if (originalKey === undefined) {
+        delete process.env.CLIPROXY_MANAGEMENT_KEY
+      } else {
+        process.env.CLIPROXY_MANAGEMENT_KEY = originalKey
+      }
+    }
+  })
 })