@marcusrbrown/infra 0.10.4 → 0.11.0

package/README.md

@@ -45,6 +45,7 @@ Manage the CLIProxyAPI proxy on `cliproxy.fro.bot`.
 | Subcommand        | Description                                                              |
 | ----------------- | ------------------------------------------------------------------------ |
 | `cliproxy status` | HTTP reachability, usage stats, version                                  |
+| `cliproxy models` | List models served at /v1/models; optional `[provider]` filter           |
 | `cliproxy deploy` | Trigger deployment (GitHub Actions by default; `--local` for direct SSH) |
 | `cliproxy config` | Get or set proxy configuration via the management API                    |
 | `cliproxy keys`   | List, add, or remove API keys via the management API                     |
@@ -54,6 +55,8 @@ Manage the CLIProxyAPI proxy on `cliproxy.fro.bot`.
 
 ```bash
 bunx @marcusrbrown/infra cliproxy status
+bunx @marcusrbrown/infra cliproxy models
+bunx @marcusrbrown/infra cliproxy models anthropic
 bunx @marcusrbrown/infra cliproxy deploy
 bunx @marcusrbrown/infra cliproxy config get
 bunx @marcusrbrown/infra cliproxy config set

package/package.json

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

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

@@ -76,6 +76,13 @@ Commands:
     --host [host]                      CLIProxyAPI droplet host for SSH execution. Falls back to CLIPROXY_DOMAIN or cliproxy.fro.bot.
 
 
+  cliproxy models [provider]           List the models CLIProxyAPI serves.
+
+    --url [url]                        Base URL for CLIProxyAPI. Falls back to CLIPROXY_URL or https://cliproxy.fro.bot.
+    --key [key]                        API key (bearer). Falls back to CLIPROXY_API_KEY when omitted.
+    --verbose                          Show owned_by and created date for each model.
+
+
   cliproxy open                        Launch CLIProxyAPI TUI dashboard via SSH.
 
     --host [host]                      SSH host for CLIProxyAPI server. Falls back to CLIPROXY_DOMAIN or cliproxy.fro.bot.

package/src/commands/cliproxy/index.ts

@@ -4,6 +4,7 @@ import {registerCliproxyConfig} from './config'
 import {registerCliproxyDeploy} from './deploy'
 import {registerCliproxyKeys} from './keys'
 import {registerCliproxyLogin} from './login'
+import {registerCliproxyModels} from './models'
 import {registerCliproxyOpen} from './open'
 import {registerCliproxySetup} from './setup'
 import {registerCliproxyStatus} from './status'
@@ -14,6 +15,7 @@ export function registerCliproxyCommands(cli: ReturnType<typeof goke>): void {
   registerCliproxyConfig(cli)
   registerCliproxyKeys(cli)
   registerCliproxyLogin(cli)
+  registerCliproxyModels(cli)
   registerCliproxyOpen(cli)
   registerCliproxySetup(cli)
 }

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

@@ -0,0 +1,356 @@
+import {afterEach, beforeEach, describe, expect, it} from 'bun:test'
+import {goke} from 'goke'
+
+import {createCapturedCtx, MockProcessExit} from '../../__test__/mcp-ctx-fixture'
+import {cliproxyModelsAction, registerCliproxyModels} from './models'
+
+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},
+  )
+}
+
+const MIXED_MODELS_RESPONSE = {
+  object: 'list',
+  data: [
+    {id: 'claude-3-5-sonnet-20241022', object: 'model', owned_by: 'anthropic', created: 1_700_000_000},
+    {id: 'claude-opus-4', object: 'model', owned_by: 'anthropic', created: 1_710_000_000},
+    {id: 'gpt-4o', object: 'model', owned_by: 'openai', created: 1_705_000_000},
+    {id: 'gpt-4o-mini', object: 'model', owned_by: 'openai', created: 1_706_000_000},
+  ],
+}
+
+const OPENAI_ONLY_RESPONSE = {
+  object: 'list',
+  data: [
+    {id: 'gpt-4o', object: 'model', owned_by: 'openai', created: 1_705_000_000},
+    {id: 'gpt-4o-mini', object: 'model', owned_by: 'openai', created: 1_706_000_000},
+  ],
+}
+
+// Models without owned_by — provider inferred from id prefix
+const NO_OWNED_BY_RESPONSE = {
+  object: 'list',
+  data: [
+    {id: 'claude-3-5-sonnet-20241022', object: 'model', created: 1_700_000_000},
+    {id: 'gpt-4o', object: 'model', created: 1_705_000_000},
+  ],
+}
+
+describe('cliproxyModelsAction — plain output', () => {
+  beforeEach(() => {
+    globalThis.fetch = createFetchImplementation(async () => {
+      throw new Error('Unexpected fetch call')
+    })
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('lists all model ids one per line when no provider filter', async () => {
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(MIXED_MODELS_RESPONSE), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    await cliproxyModelsAction({url: 'https://cliproxy.example.com', key: 'test-api-key'}, ctx)
+
+    const output = captured.stdout.join('\n')
+    expect(output).toContain('claude-3-5-sonnet-20241022')
+    expect(output).toContain('claude-opus-4')
+    expect(output).toContain('gpt-4o')
+    expect(output).toContain('gpt-4o-mini')
+  })
+
+  it('filters to openai models only when provider=openai', async () => {
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(MIXED_MODELS_RESPONSE), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    await cliproxyModelsAction({url: 'https://cliproxy.example.com', key: 'test-api-key', provider: 'openai'}, ctx)
+
+    const output = captured.stdout.join('\n')
+    expect(output).toContain('gpt-4o')
+    expect(output).toContain('gpt-4o-mini')
+    expect(output).not.toContain('claude')
+  })
+
+  it('matches provider via id prefix when owned_by is absent', async () => {
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(NO_OWNED_BY_RESPONSE), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    await cliproxyModelsAction({url: 'https://cliproxy.example.com', key: 'test-api-key', provider: 'anthropic'}, ctx)
+
+    const output = captured.stdout.join('\n')
+    expect(output).toContain('claude-3-5-sonnet-20241022')
+    expect(output).not.toContain('gpt-4o')
+  })
+})
+
+describe('cliproxyModelsAction — verbose output', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('shows owned_by and formatted date in verbose mode', async () => {
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(OPENAI_ONLY_RESPONSE), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    await cliproxyModelsAction({url: 'https://cliproxy.example.com', key: 'test-api-key', verbose: true}, ctx)
+
+    const output = captured.stdout.join('\n')
+    expect(output).toContain('gpt-4o')
+    expect(output).toContain('openai')
+    // created=1705000000 → 2024-01-11 or similar ISO date prefix
+    expect(output).toMatch(/\d{4}-\d{2}-\d{2}/)
+  })
+})
+
+describe('cliproxyModelsAction — empty results', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('prints "No models." when data array is empty', async () => {
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify({object: 'list', data: []}), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    await cliproxyModelsAction({url: 'https://cliproxy.example.com', key: 'test-api-key'}, ctx)
+
+    const output = captured.stdout.join('\n')
+    expect(output).toContain('No models')
+    expect(captured.exit).toBeNull()
+  })
+
+  it('prints provider-specific "No models" message when filter yields zero matches', async () => {
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(OPENAI_ONLY_RESPONSE), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    await cliproxyModelsAction({url: 'https://cliproxy.example.com', key: 'test-api-key', provider: 'anthropic'}, ctx)
+
+    const output = captured.stdout.join('\n')
+    expect(output).toContain('for provider anthropic')
+    expect(captured.exit).toBeNull()
+  })
+})
+
+describe('cliproxyModelsAction — validation errors', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('exits with error for unknown provider without making a fetch call', async () => {
+    let fetchCalled = false
+    globalThis.fetch = createFetchImplementation(async () => {
+      fetchCalled = true
+      return new Response('{}', {status: 200})
+    })
+
+    const {ctx, captured} = createCapturedCtx()
+    await expect(
+      cliproxyModelsAction({url: 'https://cliproxy.example.com', key: 'test-api-key', provider: 'gemini'}, ctx),
+    ).rejects.toMatchObject({name: 'MockProcessExit', code: 1})
+
+    expect(fetchCalled).toBe(false)
+    expect(captured.stderr.join('')).toMatch(/gemini|provider/i)
+    expect(captured.exit).toEqual({code: 1})
+  })
+
+  it('exits with error when no API key is provided', async () => {
+    const savedKey = process.env.CLIPROXY_API_KEY
+    delete process.env.CLIPROXY_API_KEY
+
+    try {
+      const {ctx, captured} = createCapturedCtx()
+      await expect(cliproxyModelsAction({url: 'https://cliproxy.example.com'}, ctx)).rejects.toMatchObject({
+        name: 'MockProcessExit',
+        code: 1,
+      })
+
+      expect(captured.stderr.join('')).toMatch(/key|CLIPROXY_API_KEY/i)
+      expect(captured.exit).toEqual({code: 1})
+    } finally {
+      if (savedKey !== undefined) process.env.CLIPROXY_API_KEY = savedKey
+    }
+  })
+})
+
+describe('cliproxyModelsAction — HTTP errors', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('exits with error on 401 and does not include the bearer key in output', async () => {
+    const secretKey = 'super-secret-api-key-12345'
+
+    globalThis.fetch = createFetchImplementation(async () => new Response('Unauthorized', {status: 401}))
+
+    const {ctx, captured} = createCapturedCtx()
+    await expect(
+      cliproxyModelsAction({url: 'https://cliproxy.example.com', key: secretKey}, ctx),
+    ).rejects.toMatchObject({name: 'MockProcessExit', code: 1})
+
+    const allOutput = [...captured.stdout, ...captured.stderr].join('\n')
+    expect(allOutput).not.toContain(secretKey)
+    expect(captured.exit).toEqual({code: 1})
+  })
+
+  it('exits with error on malformed JSON response', async () => {
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response('not valid json {{{', {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        }),
+    )
+
+    const {ctx, captured} = createCapturedCtx()
+    await expect(
+      cliproxyModelsAction({url: 'https://cliproxy.example.com', key: 'test-api-key'}, ctx),
+    ).rejects.toMatchObject({name: 'MockProcessExit', code: 1})
+
+    expect(captured.stderr.join('')).toMatch(/json|malformed|parse/i)
+    expect(captured.exit).toEqual({code: 1})
+  })
+})
+
+describe('cliproxyModelsAction — ambient key not forwarded to untrusted URL', () => {
+  let originalEnv: Record<string, string | undefined>
+
+  beforeEach(() => {
+    originalEnv = {
+      CLIPROXY_URL: process.env.CLIPROXY_URL,
+      CLIPROXY_API_KEY: process.env.CLIPROXY_API_KEY,
+    }
+    process.env.CLIPROXY_API_KEY = 'ambient-secret-key'
+    delete process.env.CLIPROXY_URL
+  })
+
+  afterEach(() => {
+    for (const [k, v] of Object.entries(originalEnv)) {
+      if (v === undefined) {
+        delete process.env[k]
+      } else {
+        process.env[k] = v
+      }
+    }
+    globalThis.fetch = originalFetch
+  })
+
+  it('does not forward ambient CLIPROXY_API_KEY to a non-trusted --url', async () => {
+    let capturedAuthHeader: string | null | undefined
+    let fetchCalled = false
+
+    globalThis.fetch = createFetchImplementation(async (_url, init) => {
+      fetchCalled = true
+      const hdrs = init?.headers
+      if (hdrs instanceof Headers) {
+        capturedAuthHeader = hdrs.get('Authorization')
+      } else if (hdrs !== null && hdrs !== undefined && typeof hdrs === 'object') {
+        const h = hdrs as Record<string, string>
+        capturedAuthHeader = h.Authorization ?? h.authorization ?? null
+      } else {
+        capturedAuthHeader = null
+      }
+
+      return new Response(JSON.stringify({object: 'list', data: []}), {
+        status: 200,
+        headers: {'content-type': 'application/json'},
+      })
+    })
+
+    const {ctx, captured} = createCapturedCtx()
+    // Pass an explicit untrusted URL with no --key.
+    // The ambient CLIPROXY_API_KEY must NOT be forwarded to the untrusted host.
+    // Two valid outcomes: (a) no fetch is made at all (key withheld → "No API key" error),
+    // or (b) fetch is made but without the ambient key in the Authorization header.
+    try {
+      await cliproxyModelsAction({url: 'https://evil.example.com'}, ctx)
+    } catch (error) {
+      if (!(error instanceof MockProcessExit)) throw error
+    }
+
+    if (fetchCalled) {
+      // If a fetch was made, the ambient key must not appear in the Authorization header
+      if (capturedAuthHeader !== null && capturedAuthHeader !== undefined) {
+        expect(capturedAuthHeader).not.toContain('ambient-secret-key')
+      }
+    } else {
+      // No fetch made — key was withheld entirely (correct behavior)
+      // Verify the error output doesn't contain the ambient key either
+      const allOutput = [...captured.stdout, ...captured.stderr].join('\n')
+      expect(allOutput).not.toContain('ambient-secret-key')
+    }
+  })
+})
+
+describe('registerCliproxyModels — help output and command discovery', () => {
+  it('shows [provider] positional, --url, --key, and --verbose in help text', () => {
+    const cli = goke('infra')
+    registerCliproxyModels(cli)
+    cli.help()
+
+    const helpText = cli.helpText()
+
+    expect(helpText).toContain('cliproxy models')
+    expect(helpText).toContain('[provider]')
+    expect(helpText).toContain('--url [url]')
+    expect(helpText).toContain('--key [key]')
+    expect(helpText).toContain('--verbose')
+  })
+
+  it('command is discoverable in the registered cliproxy group', () => {
+    const cli = goke('infra')
+    registerCliproxyModels(cli)
+    cli.help()
+
+    const helpText = cli.helpText()
+
+    expect(helpText).toContain('List the models CLIProxyAPI serves.')
+  })
+})

package/src/commands/cliproxy/models.ts

@@ -0,0 +1,163 @@
+import type {goke} from 'goke'
+import type {ActionCtx} from '../../lib/action-ctx'
+
+import {z} from 'zod'
+
+import {requestJson} from './shared'
+
+declare const process: {
+  env: Record<string, string | undefined>
+}
+
+const DEFAULT_CLIPROXY_URL = 'https://cliproxy.fro.bot'
+
+function stripTrailingSlash(value: string): string {
+  return value.endsWith('/') ? value.slice(0, -1) : value
+}
+
+// Permissive schema: unknown fields preserved via passthrough().
+// owned_by is optional — CLIProxyAPI v7 may omit it; provider is inferred from id instead.
+const modelEntrySchema = z
+  .object({
+    id: z.string(),
+    owned_by: z.string().optional(),
+  })
+  .passthrough()
+
+const modelsResponseSchema = z
+  .object({
+    data: z.array(modelEntrySchema),
+  })
+  .passthrough()
+
+type ModelEntry = z.infer<typeof modelEntrySchema>
+
+// Known bare-id patterns per provider, used only when owned_by is absent
+// (e.g. CLIProxyAPI v7 omits owned_by from /v1/models entries).
+const PROVIDER_ID_PATTERNS: Record<string, RegExp> = {
+  openai: /^(?:gpt-|o1-|o3-|codex)/i,
+  anthropic: /^claude-/i,
+}
+
+const VALID_PROVIDERS = ['anthropic', 'openai'] as const
+type ValidProvider = (typeof VALID_PROVIDERS)[number]
+
+function isValidProvider(value: string): value is ValidProvider {
+  return (VALID_PROVIDERS as readonly string[]).includes(value)
+}
+
+/**
+ * Decides whether a /v1/models entry belongs to a provider.
+ * Prefers owned_by when present; falls back to id prefix / known bare-id
+ * patterns when absent. Display/validation-only — never an auth or trust signal.
+ */
+function entryMatchesProvider(entry: ModelEntry, provider: string): boolean {
+  if (entry.owned_by !== undefined && entry.owned_by.trim() !== '') {
+    return entry.owned_by === provider
+  }
+  const id = entry.id ?? ''
+  if (id.startsWith(`${provider}/`)) {
+    return true
+  }
+  const pattern = PROVIDER_ID_PATTERNS[provider]
+  return pattern === undefined ? false : pattern.test(id)
+}
+
+export interface ModelsOptions {
+  url?: string
+  key?: string
+  verbose?: boolean
+  provider?: string
+}
+
+export async function cliproxyModelsAction(options: ModelsOptions, ctx: ActionCtx): Promise<void> {
+  try {
+    const baseUrl = stripTrailingSlash(options.url ?? process.env.CLIPROXY_URL ?? DEFAULT_CLIPROXY_URL)
+
+    // Trusted URL: the canonical configured/default host, trailing-slash-normalized.
+    // Ambient env keys must ONLY follow to this trusted destination to prevent
+    // secret exfiltration when an agent passes an attacker-controlled --url.
+    const trustedUrl = stripTrailingSlash(process.env.CLIPROXY_URL ?? DEFAULT_CLIPROXY_URL)
+    const urlIsExplicitlyOverridden = options.url !== undefined && baseUrl !== trustedUrl
+
+    // An explicit --key is always honored (operator knows what they're doing).
+    // An ambient env key is only forwarded when the resolved baseUrl is trusted.
+    const key = options.key ?? (urlIsExplicitlyOverridden ? undefined : process.env.CLIPROXY_API_KEY)
+
+    if (!key) {
+      throw new Error('No API key. Provide --key or set CLIPROXY_API_KEY.')
+    }
+
+    // Validate provider before any HTTP call
+    if (options.provider !== undefined && !isValidProvider(options.provider)) {
+      throw new Error(`Unknown provider "${options.provider}". Use anthropic or openai.`)
+    }
+
+    const endpoint = `${baseUrl}/v1/models`
+    const raw = await requestJson(endpoint, {
+      headers: {Authorization: `Bearer ${key}`},
+    })
+
+    const parseResult = modelsResponseSchema.safeParse(raw)
+    if (!parseResult.success) {
+      const message = parseResult.error.issues.map(issue => `${issue.path.join('.')}: ${issue.message}`).join('; ')
+      throw new Error(`Malformed /v1/models response: ${message}`)
+    }
+
+    let entries = parseResult.data.data
+
+    if (options.provider !== undefined) {
+      entries = entries.filter(e => entryMatchesProvider(e, options.provider as string))
+    }
+
+    if (entries.length === 0) {
+      ctx.console.log(
+        options.provider === undefined ? 'No models.' : `No models found for provider ${options.provider}.`,
+      )
+      return
+    }
+
+    if (options.verbose) {
+      // Aligned columns: id, owned_by (or '-' if absent), created as ISO date
+      const idWidth = Math.max(...entries.map(e => e.id.length), 2)
+      const ownerWidth = Math.max(...entries.map(e => (e.owned_by ?? '-').length), 8)
+
+      for (const entry of entries) {
+        const id = entry.id.padEnd(idWidth)
+        const owner = (entry.owned_by ?? '-').padEnd(ownerWidth)
+        const date = typeof entry.created === 'number' ? new Date(entry.created * 1000).toISOString().slice(0, 10) : '-'
+        ctx.console.log(`${id}  ${owner}  ${date}`)
+      }
+    } else {
+      for (const entry of entries) {
+        ctx.console.log(entry.id)
+      }
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    ctx.console.error(message)
+    ctx.process.exit(1)
+  }
+}
+
+export function registerCliproxyModels(cli: ReturnType<typeof goke>): void {
+  cli
+    .command('cliproxy models [provider]', 'List the models CLIProxyAPI serves.')
+    .option(
+      '--url [url]',
+      z.string().describe('Base URL for CLIProxyAPI. Falls back to CLIPROXY_URL or https://cliproxy.fro.bot.'),
+    )
+    .option('--key [key]', z.string().describe('API key (bearer). Falls back to CLIPROXY_API_KEY when omitted.'))
+    .option('--verbose', 'Show owned_by and created date for each model.')
+    .example('# List all models served by CLIProxyAPI')
+    .example('infra cliproxy models')
+    .example('# Filter to Anthropic models only')
+    .example('infra cliproxy models anthropic')
+    .example('# Show verbose output with owned_by and created date')
+    .example('infra cliproxy models --verbose')
+    .example('# Filter to OpenAI models with verbose output')
+    .example('infra cliproxy models openai --verbose')
+    .action((provider, options, ctx) =>
+      cliproxyModelsAction({...options, provider: provider as string | undefined}, ctx),
+    )
+}

package/src/commands/mcp.test.ts

@@ -26,7 +26,7 @@
 import {createMcpAction} from '@goke/mcp'
 import {Client} from '@modelcontextprotocol/sdk/client'
 import {InMemoryTransport} from '@modelcontextprotocol/sdk/inMemory.js'
-import {afterAll, beforeAll, describe, expect, test} from 'bun:test'
+import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, test} from 'bun:test'
 import {goke} from 'goke'
 
 import {registerCliproxyCommands} from './cliproxy'
@@ -42,9 +42,10 @@ import {registerVpnCommands} from './vpn'
 /**
  * The MCP tool surface, pinned as an INDEPENDENT literal (deliberately NOT
  * derived from MCP_ALLOWLIST) so allowlist drift surfaces as a test failure —
- * per the Tier-1 test bar in packages/cli/AGENTS.md. Six read-only status tools.
+ * per the Tier-1 test bar in packages/cli/AGENTS.md. Seven read-only tools.
  */
 const EXPECTED_TOOLS = [
+  'cliproxy_models',
   'cliproxy_status',
   'gateway_status',
   'keeweb_status',
@@ -151,3 +152,104 @@ describe('mcp integration (Tier-1, in-process)', () => {
     }
   })
 })
+
+// ─── cliproxy_models end-to-end call (Tier-1, in-process) ────────────────────
+
+const MODELS_RESPONSE = {
+  object: 'list',
+  data: [
+    {id: 'claude-opus-4', object: 'model', owned_by: 'anthropic', created: 1_710_000_000},
+    {id: 'claude-sonnet-4-5', object: 'model', owned_by: 'anthropic', created: 1_715_000_000},
+    {id: 'gpt-4o', object: 'model', owned_by: 'openai', created: 1_705_000_000},
+  ],
+}
+
+type FetchReplacement = (url: string, init?: RequestInit) => Promise<Response>
+
+function createFetchImplementation(handler: FetchReplacement): typeof fetch {
+  const originalFetch = globalThis.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_models MCP tool (Tier-1, in-process call)', () => {
+  let callClient: Client
+  const originalFetch = globalThis.fetch
+  let savedApiKey: string | undefined
+
+  beforeAll(async () => {
+    const cli = buildTestCli()
+    cli.matchedCommandName = 'mcp'
+
+    const [serverTransport, clientTransport] = InMemoryTransport.createLinkedPair()
+
+    const mcpAction = createMcpAction({
+      cli,
+      commandFilter: (name: string) => MCP_ALLOWLIST.has(name),
+      createTransport: () => serverTransport,
+    })
+
+    await mcpAction()
+
+    callClient = new Client({name: 'test-client-models', version: '1.0.0'}, {capabilities: {}})
+    await callClient.connect(clientTransport)
+  })
+
+  afterAll(async () => {
+    await callClient?.close()
+  })
+
+  beforeEach(() => {
+    savedApiKey = process.env.CLIPROXY_API_KEY
+    process.env.CLIPROXY_API_KEY = 'test-mcp-api-key'
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    if (savedApiKey === undefined) {
+      delete process.env.CLIPROXY_API_KEY
+    } else {
+      process.env.CLIPROXY_API_KEY = savedApiKey
+    }
+  })
+
+  test('listTools() includes cliproxy_models', async () => {
+    const result = await callClient.listTools()
+    const names = result.tools.map((t: {name: string}) => t.name)
+    expect(names).toContain('cliproxy_models')
+  })
+
+  test('calling cliproxy_models returns captured model-list text with expected model ids', async () => {
+    globalThis.fetch = createFetchImplementation(async url => {
+      if (url.includes('/v1/models')) {
+        return new Response(JSON.stringify(MODELS_RESPONSE), {
+          status: 200,
+          headers: {'content-type': 'application/json'},
+        })
+      }
+
+      throw new Error(`Unexpected fetch: ${url}`)
+    })
+
+    const result = await callClient.callTool({name: 'cliproxy_models', arguments: {}})
+
+    // MCP tool result is an array of content blocks; join text content for assertion
+    const content = result.content as {type: string; text?: string}[]
+    const text = content
+      .filter(c => c.type === 'text')
+      .map(c => c.text ?? '')
+      .join('\n')
+
+    expect(text).toContain('claude-opus-4')
+    expect(text).toContain('claude-sonnet-4-5')
+    expect(text).toContain('gpt-4o')
+  })
+})

package/src/commands/mcp.ts

@@ -38,6 +38,7 @@ import {createMcpAction} from '@goke/mcp'
 export const MCP_ALLOWLIST: ReadonlySet<string> = new Set([
   'gateway status',
   'cliproxy status',
+  'cliproxy models',
   'keeweb status',
   'umami status',
   'vpn status',