@marcusrbrown/infra 0.10.5 → 0.11.1

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.5",
+  "version": "0.11.1",
   "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,592 @@
+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},
+  )
+}
+
+// Fixture: mixed providers with known created timestamps for ordering assertions.
+// anthropic group: claude-3-5-sonnet (created=1700000000) < claude-opus-4 (created=1710000000)
+// openai group: gpt-4o (created=1705000000) < gpt-4o-mini (created=1706000000)
+// Provider groups sorted ascending: anthropic < openai
+// Expected plain order: anthropic/claude-3-5-sonnet-20241022, anthropic/claude-opus-4, openai/gpt-4o, openai/gpt-4o-mini
+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},
+  ],
+}
+
+// Model with no owned_by and no matching pattern → unknown provider
+const UNKNOWN_PROVIDER_RESPONSE = {
+  object: 'list',
+  data: [
+    {id: 'claude-3-5-sonnet-20241022', object: 'model', owned_by: 'anthropic', created: 1_700_000_000},
+    {id: 'some-mystery-model-v1', object: 'model', created: 1_715_000_000},
+  ],
+}
+
+// Fixture with deliberately reversed order to test date-asc sorting within a group
+const REVERSED_ORDER_RESPONSE = {
+  object: 'list',
+  data: [
+    {id: 'claude-opus-4', object: 'model', owned_by: 'anthropic', created: 1_710_000_000},
+    {id: 'claude-3-5-sonnet-20241022', object: 'model', owned_by: 'anthropic', created: 1_700_000_000},
+  ],
+}
+
+describe('cliproxyModelsAction — plain output', () => {
+  beforeEach(() => {
+    globalThis.fetch = createFetchImplementation(async () => {
+      throw new Error('Unexpected fetch call')
+    })
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('emits provider/id format (not bare id) for each model', 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('anthropic/claude-3-5-sonnet-20241022')
+    expect(output).toContain('anthropic/claude-opus-4')
+    expect(output).toContain('openai/gpt-4o')
+    expect(output).toContain('openai/gpt-4o-mini')
+    // Must NOT emit bare ids without prefix
+    expect(output).not.toMatch(/^claude-/m)
+    expect(output).not.toMatch(/^gpt-/m)
+  })
+
+  it('groups by provider (anthropic before openai) and sorts date-asc within each group', 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 lines = captured.stdout.join('\n').split('\n').filter(Boolean)
+    expect(lines).toEqual([
+      'anthropic/claude-3-5-sonnet-20241022',
+      'anthropic/claude-opus-4',
+      'openai/gpt-4o',
+      'openai/gpt-4o-mini',
+    ])
+  })
+
+  it('sorts date-asc within a provider group even when API returns them in reverse order', async () => {
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(REVERSED_ORDER_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 lines = captured.stdout.join('\n').split('\n').filter(Boolean)
+    // claude-3-5-sonnet (created=1700000000) must come before claude-opus-4 (created=1710000000)
+    expect(lines).toEqual(['anthropic/claude-3-5-sonnet-20241022', 'anthropic/claude-opus-4'])
+  })
+
+  it('filters to openai models only when provider=openai, still emits provider/id', 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('openai/gpt-4o')
+    expect(output).toContain('openai/gpt-4o-mini')
+    expect(output).not.toContain('claude')
+  })
+
+  it('infers anthropic provider via id pattern 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('anthropic/claude-3-5-sonnet-20241022')
+    expect(output).not.toContain('gpt-4o')
+  })
+
+  it('infers openai provider via id pattern 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: 'openai'}, ctx)
+
+    const output = captured.stdout.join('\n')
+    expect(output).toContain('openai/gpt-4o')
+    expect(output).not.toContain('claude')
+  })
+
+  it('prefixes unknown/<id> for entries with no owned_by and no matching pattern, sorted last', async () => {
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(UNKNOWN_PROVIDER_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 lines = captured.stdout.join('\n').split('\n').filter(Boolean)
+    // anthropic group first, unknown group last
+    expect(lines[0]).toBe('anthropic/claude-3-5-sonnet-20241022')
+    expect(lines.at(-1)).toBe('unknown/some-mystery-model-v1')
+  })
+
+  it('does not double-prefix an id that already has a provider/ prefix', async () => {
+    const alreadyPrefixedResponse = {
+      object: 'list',
+      data: [{id: 'anthropic/claude-opus-4', object: 'model', owned_by: 'anthropic', created: 1_710_000_000}],
+    }
+
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(alreadyPrefixedResponse), {
+          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('anthropic/claude-opus-4')
+    expect(output).not.toContain('anthropic/anthropic/')
+  })
+})
+
+describe('cliproxyModelsAction — verbose output', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('emits a single valid JSON array parseable by JSON.parse', 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 raw = captured.stdout.join('')
+    const parsed = JSON.parse(raw)
+    expect(Array.isArray(parsed)).toBe(true)
+  })
+
+  it('verbose entries have {id, provider, raw_id, created} shape with prefixed id', 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 parsed: {id: string; provider: string; raw_id: string; created: string | null}[] = JSON.parse(
+      captured.stdout.join(''),
+    )
+    expect(parsed.length).toBe(2)
+
+    // parsed.length === 2 asserted above; non-null access is safe
+    const first = parsed[0]!
+    expect(first).toHaveProperty('id')
+    expect(first).toHaveProperty('provider')
+    expect(first).toHaveProperty('raw_id')
+    expect(first).toHaveProperty('created')
+    // id must be prefixed
+    expect(first.id).toBe('openai/gpt-4o')
+    expect(first.provider).toBe('openai')
+    expect(first.raw_id).toBe('gpt-4o')
+    // created is ISO 8601 string
+    expect(typeof first.created).toBe('string')
+    expect(first.created).toMatch(/^\d{4}-\d{2}-\d{2}T/)
+  })
+
+  it('verbose output is date-asc sorted and provider-grouped (anthropic before 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', verbose: true}, ctx)
+
+    const parsed: {id: string; provider: string; raw_id: string; created: string | null}[] = JSON.parse(
+      captured.stdout.join(''),
+    )
+    expect(parsed.map(e => e.id)).toEqual([
+      'anthropic/claude-3-5-sonnet-20241022',
+      'anthropic/claude-opus-4',
+      'openai/gpt-4o',
+      'openai/gpt-4o-mini',
+    ])
+  })
+
+  it('verbose with empty data emits [] (not a text message)', 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', verbose: true}, ctx)
+
+    const raw = captured.stdout.join('')
+    const parsed = JSON.parse(raw)
+    expect(parsed).toEqual([])
+  })
+
+  it('verbose with zero-match provider filter emits [] (not a text message)', 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, provider: 'anthropic'},
+      ctx,
+    )
+
+    const raw = captured.stdout.join('')
+    const parsed = JSON.parse(raw)
+    expect(parsed).toEqual([])
+  })
+
+  it('verbose: created is null when entry has no created timestamp', async () => {
+    const noCreatedResponse = {
+      object: 'list',
+      data: [{id: 'gpt-4o', object: 'model', owned_by: 'openai'}],
+    }
+
+    globalThis.fetch = createFetchImplementation(
+      async () =>
+        new Response(JSON.stringify(noCreatedResponse), {
+          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 parsed: {id: string; provider: string; raw_id: string; created: string | null}[] = JSON.parse(
+      captured.stdout.join(''),
+    )
+    expect(parsed.length).toBe(1)
+    // parsed.length === 1 asserted above; non-null access is safe
+    expect(parsed[0]!.created).toBeNull()
+  })
+})
+
+describe('cliproxyModelsAction — empty results', () => {
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+  })
+
+  it('prints "No models." when data array is empty (non-verbose)', 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 (non-verbose)', 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,237 @@
+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(),
+    created: z.number().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)
+}
+
+/**
+ * Derives the provider string for a model entry.
+ * Prefers owned_by when present and non-empty; falls back to PROVIDER_ID_PATTERNS
+ * matching against the bare id; falls back to 'unknown'.
+ * Display/validation-only — never an auth or trust signal.
+ */
+function deriveProvider(entry: ModelEntry): string {
+  if (entry.owned_by !== undefined && entry.owned_by.trim() !== '') {
+    return entry.owned_by
+  }
+  // Strip any existing provider/ prefix before pattern matching
+  const bareId = stripProviderPrefix(entry.id)
+  for (const [provider, pattern] of Object.entries(PROVIDER_ID_PATTERNS)) {
+    if (pattern.test(bareId)) return provider
+  }
+  return 'unknown'
+}
+
+/**
+ * Strips an existing `provider/` prefix from a raw id, if present.
+ * Defensive: handles entries that already have a prefix so we don't double-prefix.
+ */
+function stripProviderPrefix(id: string): string {
+  const slashIdx = id.indexOf('/')
+  if (slashIdx === -1) return id
+  // Only strip if the prefix looks like a known provider or 'unknown'
+  const prefix = id.slice(0, slashIdx)
+  if (prefix === 'unknown' || isValidProvider(prefix)) {
+    return id.slice(slashIdx + 1)
+  }
+  return id
+}
+
+/**
+ * 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 {
+  return deriveProvider(entry) === provider
+}
+
+/**
+ * Sort entries: grouped by provider (ascending), within each group by created asc.
+ * Entries with missing/non-number created sort last within their group.
+ */
+function sortEntries(entries: ModelEntry[]): ModelEntry[] {
+  // Annotate with derived provider for stable grouping
+  const annotated = entries.map(e => ({entry: e, provider: deriveProvider(e)}))
+
+  // Sort: provider asc, then created asc (missing created → Infinity → sorts last)
+  annotated.sort((a, b) => {
+    const providerCmp = a.provider.localeCompare(b.provider)
+    if (providerCmp !== 0) return providerCmp
+    const aCreated = typeof a.entry.created === 'number' ? a.entry.created : Infinity
+    const bCreated = typeof b.entry.created === 'number' ? b.entry.created : Infinity
+    return aCreated - bCreated
+  })
+
+  return annotated.map(a => a.entry)
+}
+
+/**
+ * Formats a model entry for plain output: `provider/raw_id`.
+ */
+function formatPlainLine(entry: ModelEntry): string {
+  const provider = deriveProvider(entry)
+  const rawId = stripProviderPrefix(entry.id)
+  return `${provider}/${rawId}`
+}
+
+interface VerboseEntry {
+  id: string
+  provider: string
+  raw_id: string
+  created: string | null
+}
+
+/**
+ * Formats a model entry for verbose JSON output.
+ */
+function formatVerboseEntry(entry: ModelEntry): VerboseEntry {
+  const provider = deriveProvider(entry)
+  const rawId = stripProviderPrefix(entry.id)
+  return {
+    id: `${provider}/${rawId}`,
+    provider,
+    raw_id: rawId,
+    created: typeof entry.created === 'number' ? new Date(entry.created * 1000).toISOString() : null,
+  }
+}
+
+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))
+    }
+
+    // Sort: provider-grouped (asc), date-asc within each group
+    entries = sortEntries(entries)
+
+    if (options.verbose) {
+      // --verbose: emit a single JSON array (pretty-printed) of the fields we have.
+      // Always valid JSON — empty/zero-match → [].
+      const verboseEntries = entries.map(formatVerboseEntry)
+      ctx.console.log(JSON.stringify(verboseEntries, null, 2))
+      return
+    }
+
+    if (entries.length === 0) {
+      ctx.console.log(
+        options.provider === undefined ? 'No models.' : `No models found for provider ${options.provider}.`,
+      )
+      return
+    }
+
+    for (const entry of entries) {
+      ctx.console.log(formatPlainLine(entry))
+    }
+  } 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',