@marcusrbrown/infra 0.7.0 → 0.8.1

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

@@ -0,0 +1,159 @@
+/// <reference types="bun" />
+
+import {describe, expect, it} from 'bun:test'
+
+import {formatDryRunPreview} from './preview'
+import {getHarnessTemplate} from './templates'
+
+const KEY = 'sk-placeholder'
+const BASE_URL = 'https://cliproxy.fro.bot'
+
+describe('formatDryRunPreview', () => {
+  it('renders the dry-run header with repo and providers', () => {
+    const template = getHarnessTemplate('opencode', {keyValue: KEY, baseUrl: BASE_URL})
+    const preview = formatDryRunPreview({
+      repo: 'owner/repo',
+      harness: 'opencode',
+      providers: ['anthropic'],
+      model: 'anthropic/claude-sonnet-4-6',
+      template,
+    })
+
+    expect(preview).toContain('Dry run: cliproxy setup --harness opencode')
+    expect(preview).toContain('Repository: owner/repo')
+    expect(preview).toContain('Providers: anthropic')
+  })
+
+  it('renders planned secrets with byte sizes', () => {
+    const template = getHarnessTemplate('opencode', {keyValue: KEY, baseUrl: BASE_URL})
+    const preview = formatDryRunPreview({
+      repo: 'owner/repo',
+      harness: 'opencode',
+      providers: ['anthropic'],
+      model: 'anthropic/claude-sonnet-4-6',
+      template,
+    })
+
+    expect(preview).toContain('Planned secrets:')
+    expect(preview).toContain('OPENCODE_AUTH_JSON')
+    expect(preview).toContain('OPENCODE_CONFIG')
+    expect(preview).toContain('OMO_PROVIDERS')
+  })
+
+  it('renders planned variables', () => {
+    const template = getHarnessTemplate('opencode', {keyValue: KEY, baseUrl: BASE_URL})
+    const preview = formatDryRunPreview({
+      repo: 'owner/repo',
+      harness: 'opencode',
+      providers: ['anthropic'],
+      model: 'anthropic/claude-sonnet-4-6',
+      template,
+    })
+
+    expect(preview).toContain('Planned variables:')
+    expect(preview).toContain('FRO_BOT_MODEL')
+  })
+
+  it('renders proxy key as <proxy-key> placeholder, NOT the actual key value', () => {
+    const template = getHarnessTemplate('opencode', {keyValue: KEY, baseUrl: BASE_URL})
+    const preview = formatDryRunPreview({
+      repo: 'owner/repo',
+      harness: 'opencode',
+      providers: ['anthropic'],
+      model: 'anthropic/claude-sonnet-4-6',
+      template,
+    })
+
+    expect(preview).toContain('<proxy-key>')
+    expect(preview).not.toContain(KEY)
+  })
+
+  it('renders "No mutations will be performed." footer', () => {
+    const template = getHarnessTemplate('opencode', {keyValue: KEY, baseUrl: BASE_URL})
+    const preview = formatDryRunPreview({
+      repo: 'owner/repo',
+      harness: 'opencode',
+      providers: ['anthropic'],
+      model: 'anthropic/claude-sonnet-4-6',
+      template,
+    })
+
+    expect(preview).toContain('No mutations will be performed.')
+  })
+
+  it('dual-provider preview lists both providers', () => {
+    const template = getHarnessTemplate('opencode', {
+      keyValue: KEY,
+      baseUrl: BASE_URL,
+      providers: ['anthropic', 'openai'],
+      model: 'openai/gpt-5.4-mini',
+    })
+    const preview = formatDryRunPreview({
+      repo: 'owner/repo',
+      harness: 'opencode',
+      providers: ['anthropic', 'openai'],
+      model: 'openai/gpt-5.4-mini',
+      template,
+    })
+
+    expect(preview).toContain('anthropic')
+    expect(preview).toContain('openai')
+    expect(preview).not.toContain(KEY)
+  })
+
+  it('secret values in preview do NOT contain the actual key value', () => {
+    // Even if the template has the key embedded in JSON, the preview must redact it
+    const template = getHarnessTemplate('opencode', {keyValue: KEY, baseUrl: BASE_URL})
+    const preview = formatDryRunPreview({
+      repo: 'owner/repo',
+      harness: 'opencode',
+      providers: ['anthropic'],
+      model: 'anthropic/claude-sonnet-4-6',
+      template,
+    })
+
+    // The actual key must not appear anywhere in the preview output
+    expect(preview).not.toContain(KEY)
+  })
+
+  // ── byte-count contract tests ────────────────────
+
+  it('anthropic-only: OPENCODE_AUTH_JSON is 51 bytes with sk-placeholder key', () => {
+    const template = getHarnessTemplate('opencode', {
+      keyValue: KEY,
+      baseUrl: BASE_URL,
+      providers: ['anthropic'],
+      model: 'anthropic/claude-sonnet-4-6',
+    })
+    const preview = formatDryRunPreview({
+      repo: 'owner/repo',
+      harness: 'opencode',
+      providers: ['anthropic'],
+      model: 'anthropic/claude-sonnet-4-6',
+      template,
+    })
+
+    expect(preview).toContain('Providers: anthropic')
+    expect(preview).toContain('OPENCODE_AUTH_JSON (51 bytes)')
+    expect(preview).toContain('<proxy-key>')
+  })
+
+  it('dual-provider: OPENCODE_AUTH_JSON is 98 bytes with sk-placeholder key', () => {
+    const template = getHarnessTemplate('opencode', {
+      keyValue: KEY,
+      baseUrl: BASE_URL,
+      providers: ['anthropic', 'openai'],
+      model: 'anthropic/claude-sonnet-4-6',
+    })
+    const preview = formatDryRunPreview({
+      repo: 'owner/repo',
+      harness: 'opencode',
+      providers: ['anthropic', 'openai'],
+      model: 'anthropic/claude-sonnet-4-6',
+      template,
+    })
+
+    expect(preview).toContain('Providers: anthropic, openai')
+    expect(preview).toContain('OPENCODE_AUTH_JSON (98 bytes)')
+  })
+})

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

@@ -0,0 +1,41 @@
+import type {ProviderId} from './providers'
+import type {Harness, HarnessTemplate} from './templates'
+
+export interface DryRunPreviewOptions {
+  repo: string
+  harness: Harness
+  providers: ProviderId[]
+  model: string
+  template: HarnessTemplate
+}
+
+/**
+ * Format a dry-run preview string. The proxy key value is NEVER included —
+ * it is rendered as `<proxy-key>` in all positions.
+ */
+export function formatDryRunPreview(opts: DryRunPreviewOptions): string {
+  const {repo, harness, providers, model, template} = opts
+
+  const lines: string[] = [
+    `Dry run: cliproxy setup --harness ${harness}`,
+    `Repository: ${repo}`,
+    `Providers: ${providers.join(', ')}`,
+    `Model: ${model}`,
+    'Planned secrets:',
+  ]
+
+  for (const secret of template.secrets) {
+    const size = new TextEncoder().encode(secret.value).byteLength
+    lines.push(`  - ${secret.name} (${size} bytes)`)
+  }
+
+  lines.push('Planned variables:')
+  for (const variable of template.variables) {
+    lines.push(`  - ${variable.name} = ${variable.value}`)
+  }
+
+  lines.push('Proxy key (redacted): <proxy-key>')
+  lines.push('No mutations will be performed.')
+
+  return lines.join('\n')
+}

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

@@ -0,0 +1,58 @@
+/// <reference types="bun" />
+
+import {describe, expect, it} from 'bun:test'
+
+import {buildApiKeyValue, ensureRepoFormat, ensureSecretName} from './prompts'
+
+describe('ensureRepoFormat', () => {
+  it('happy path: returns owner/repo unchanged', () => {
+    expect(ensureRepoFormat('owner/repo')).toBe('owner/repo')
+  })
+
+  it('error path: throws on whitespace in value', () => {
+    expect(() => ensureRepoFormat('owner repo')).toThrow()
+  })
+
+  it('error path: throws on extra slash', () => {
+    expect(() => ensureRepoFormat('owner/repo/extra')).toThrow()
+  })
+
+  it('error path: throws on empty string', () => {
+    expect(() => ensureRepoFormat('')).toThrow()
+  })
+})
+
+describe('ensureSecretName', () => {
+  it('happy path: returns VALID_NAME unchanged', () => {
+    expect(ensureSecretName('VALID_NAME', 'secret')).toBe('VALID_NAME')
+  })
+
+  it('error path: throws on lowercase name', () => {
+    expect(() => ensureSecretName('lower_case', 'secret')).toThrow()
+  })
+
+  it('error path: throws on name with hyphens', () => {
+    expect(() => ensureSecretName('with-dash', 'secret')).toThrow()
+  })
+
+  it('error path: throws when name starts with a digit', () => {
+    expect(() => ensureSecretName('123_START_DIGIT', 'secret')).toThrow()
+  })
+})
+
+describe('buildApiKeyValue', () => {
+  it('happy path: slugifies key name and appends uuid suffix', () => {
+    const result = buildApiKeyValue('my repo ci!')
+    expect(result).toMatch(/^sk-my-repo-ci-[a-f0-9]+$/)
+  })
+
+  it('edge case: empty string falls back to cliproxy slug', () => {
+    const result = buildApiKeyValue('')
+    expect(result).toMatch(/^sk-cliproxy-[a-f0-9]+$/)
+  })
+
+  it('edge case: uppercased input is lowercased in slug', () => {
+    const result = buildApiKeyValue('UPPERCASE')
+    expect(result).toMatch(/^sk-uppercase-[a-f0-9]+$/)
+  })
+})

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

@@ -0,0 +1,99 @@
+/// <reference types="bun" />
+
+import * as clack from '@clack/prompts'
+
+export interface GenericSecretNames {
+  apiKeySecretName: string
+  baseUrlSecretName: string
+}
+
+export function ensureRepoFormat(value: string): string {
+  const trimmed = value.trim()
+  if (!/^[^/\s]+\/[^/\s]+$/.test(trimmed)) {
+    throw new Error('Repository must be in owner/repo format.')
+  }
+  return trimmed
+}
+
+export function ensureSecretName(value: string, label: string): string {
+  const trimmed = value.trim()
+  if (!/^[A-Z][A-Z0-9_]*$/.test(trimmed)) {
+    throw new Error(`${label} must be SCREAMING_SNAKE_CASE.`)
+  }
+  return trimmed
+}
+
+export function cancelAndExit(message = 'Setup cancelled.'): never {
+  clack.cancel(message)
+  process.exit(0)
+}
+
+export async function promptValue<T extends string | boolean>(
+  promise: Promise<T | symbol>,
+  cancelMessage?: string,
+): Promise<T> {
+  const value = await promise
+  if (clack.isCancel(value)) {
+    cancelAndExit(cancelMessage)
+  }
+  return value
+}
+
+export function buildApiKeyValue(keyName: string): string {
+  const slug = (
+    keyName
+      .trim()
+      .toLowerCase()
+      .match(/[a-z0-9]+/g) ?? []
+  )
+    .join('-')
+    .slice(0, 24)
+  const random = crypto.randomUUID().split('-').join('')
+  return `sk-${slug || 'cliproxy'}-${random}`
+}
+
+function extractErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+export async function promptGenericSecretNames(): Promise<GenericSecretNames> {
+  const apiKeySecretName = ensureSecretName(
+    await promptValue(
+      clack.text({
+        message: 'Name for the API key secret',
+        placeholder: 'CLIPROXY_API_KEY',
+        validate: value => {
+          try {
+            ensureSecretName(value ?? '', 'API key secret name')
+            return undefined
+          } catch (error) {
+            return extractErrorMessage(error)
+          }
+        },
+      }),
+      'Setup cancelled before choosing the generic API key secret name.',
+    ),
+    'API key secret name',
+  )
+
+  const baseUrlSecretName = ensureSecretName(
+    await promptValue(
+      clack.text({
+        message: 'Name for the proxy base URL secret',
+        placeholder: 'CLIPROXY_BASE_URL',
+        validate: value => {
+          try {
+            ensureSecretName(value ?? '', 'Base URL secret name')
+            return undefined
+          } catch (error) {
+            return extractErrorMessage(error)
+          }
+        },
+      }),
+      'Setup cancelled before choosing the generic base URL secret name.',
+    ),
+    'Base URL secret name',
+  )
+
+  return {apiKeySecretName, baseUrlSecretName}
+}

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

@@ -0,0 +1,245 @@
+/// <reference types="bun" />
+
+import type {MultiSelectOptions, TextOptions} from '@clack/prompts'
+import {describe, expect, it, spyOn} from 'bun:test'
+
+import {parseProviders, promptForModel, promptForProviders} from './providers'
+
+// Type helper: cast a concrete-typed clack implementation to the generic spy type.
+// clack's multiselect/text/select are generic functions; Bun's spyOn preserves the
+// generic signature, so mockImplementation requires the same generic. We provide a
+// concrete instantiation and widen through `unknown` — this is safe because the
+// concrete type is a structural subtype of the generic at the call site.
+function asMultiselectImpl<V>(fn: (opts: MultiSelectOptions<V>) => Promise<V[] | symbol>) {
+  return fn as unknown as <Value>(opts: MultiSelectOptions<Value>) => Promise<Value[] | symbol>
+}
+
+function asTextImpl(fn: (opts: TextOptions) => Promise<string | symbol>) {
+  return fn as unknown as (opts: TextOptions) => Promise<string | symbol>
+}
+
+describe('option parsing', () => {
+  describe('parseProviders', () => {
+    it("parses \"anthropic,openai\" to ['anthropic', 'openai']", () => {
+      expect(parseProviders('anthropic,openai')).toEqual(['anthropic', 'openai'])
+    })
+
+    it('parses "openai" to [\'openai\']', () => {
+      expect(parseProviders('openai')).toEqual(['openai'])
+    })
+
+    it('parses "anthropic" to [\'anthropic\']', () => {
+      expect(parseProviders('anthropic')).toEqual(['anthropic'])
+    })
+
+    it('rejects duplicate providers with a "duplicate" error', () => {
+      expect(() => parseProviders('anthropic,anthropic')).toThrow(/duplicate/i)
+    })
+
+    it('rejects an empty string with a clear message', () => {
+      expect(() => parseProviders('')).toThrow()
+    })
+
+    it('rejects an unknown provider "claude" with an enum error', () => {
+      expect(() => parseProviders('claude')).toThrow()
+    })
+
+    it('trims whitespace around provider names', () => {
+      expect(parseProviders(' anthropic , openai ')).toEqual(['anthropic', 'openai'])
+    })
+
+    it('rejects "__proto__" (prototype-chain safety)', () => {
+      expect(() => parseProviders('__proto__')).toThrow()
+    })
+  })
+})
+
+describe('interactive provider/model prompts', () => {
+  // We spy on @clack/prompts functions directly since Bun's mock.module
+  // requires static hoisting. Instead we use spyOn on the imported module.
+  // The helpers call the clack functions via the module binding, so we
+  // intercept them via spyOn after importing.
+
+  // Note: Because providers.ts imports clack at module load time and calls the
+  // functions directly (not via a re-exported object), we need to use
+  // mock.module to intercept. However, Bun's mock.module must be called
+  // before the module is imported. Since providers.ts is already imported above,
+  // we test the helpers by injecting controlled behavior through the clack
+  // module mock at the describe level using beforeEach/afterEach with spyOn
+  // on the actual clack module exports.
+  //
+  // The approach: import clack directly and spyOn its exports.
+
+  describe('promptForProviders', () => {
+    it('happy path: anthropic-only selection returns [anthropic]', async () => {
+      const clack = await import('@clack/prompts')
+      // multiselect<Value> returns Promise<Value[] | symbol>; resolved value is string[] | symbol
+      const multiselectSpy = spyOn(clack, 'multiselect').mockResolvedValue(['anthropic'])
+
+      const result = await promptForProviders()
+
+      expect(result).toEqual(['anthropic'])
+      expect(multiselectSpy).toHaveBeenCalledTimes(1)
+
+      multiselectSpy.mockRestore()
+    })
+
+    it('happy path: both providers selected returns [anthropic, openai]', async () => {
+      const clack = await import('@clack/prompts')
+      const multiselectSpy = spyOn(clack, 'multiselect').mockResolvedValue(['anthropic', 'openai'])
+
+      const result = await promptForProviders()
+
+      expect(result).toEqual(['anthropic', 'openai'])
+
+      multiselectSpy.mockRestore()
+    })
+
+    it('edge case: empty selection re-prompts; multiselect called exactly twice', async () => {
+      const clack = await import('@clack/prompts')
+      let callCount = 0
+      const multiselectSpy = spyOn(clack, 'multiselect').mockImplementation(
+        asMultiselectImpl<string>(async () => {
+          callCount++
+          if (callCount === 1) return []
+          return ['anthropic']
+        }),
+      )
+
+      const result = await promptForProviders()
+
+      expect(result).toEqual(['anthropic'])
+      expect(multiselectSpy).toHaveBeenCalledTimes(2)
+
+      multiselectSpy.mockRestore()
+    })
+
+    it('edge case: cancel mid-flow causes process.exit(0)', async () => {
+      const clack = await import('@clack/prompts')
+      const cancelSymbol = Symbol('cancel')
+      const multiselectSpy = spyOn(clack, 'multiselect').mockResolvedValue(cancelSymbol)
+      const isCancelSpy = spyOn(clack, 'isCancel').mockImplementation(v => v === cancelSymbol)
+      const cancelSpy = spyOn(clack, 'cancel').mockImplementation(() => {})
+      const exitSpy = spyOn(process, 'exit').mockImplementation((_code?: number): never => {
+        throw new Error('process.exit called')
+      })
+
+      await expect(promptForProviders()).rejects.toThrow('process.exit called')
+
+      multiselectSpy.mockRestore()
+      isCancelSpy.mockRestore()
+      cancelSpy.mockRestore()
+      exitSpy.mockRestore()
+    })
+  })
+
+  describe('promptForModel', () => {
+    it('happy path: single anthropic provider returns anthropic/claude-sonnet-4-6 without prompting', async () => {
+      const clack = await import('@clack/prompts')
+      const selectSpy = spyOn(clack, 'select')
+
+      const result = await promptForModel(['anthropic'])
+
+      expect(result).toBe('anthropic/claude-sonnet-4-6')
+      expect(selectSpy).not.toHaveBeenCalled()
+
+      selectSpy.mockRestore()
+    })
+
+    it('happy path: single openai provider returns openai/gpt-5.4-mini without prompting', async () => {
+      const clack = await import('@clack/prompts')
+      const selectSpy = spyOn(clack, 'select')
+
+      const result = await promptForModel(['openai'])
+
+      expect(result).toBe('openai/gpt-5.4-mini')
+      expect(selectSpy).not.toHaveBeenCalled()
+
+      selectSpy.mockRestore()
+    })
+
+    it('happy path: both providers, operator picks openai/gpt-5.4-mini from select', async () => {
+      const clack = await import('@clack/prompts')
+      const selectSpy = spyOn(clack, 'select').mockResolvedValue('openai/gpt-5.4-mini')
+
+      const result = await promptForModel(['anthropic', 'openai'])
+
+      expect(result).toBe('openai/gpt-5.4-mini')
+      expect(selectSpy).toHaveBeenCalledTimes(1)
+
+      selectSpy.mockRestore()
+    })
+
+    it('happy path: both providers, operator picks anthropic/claude-sonnet-4-6 from select', async () => {
+      const clack = await import('@clack/prompts')
+      const selectSpy = spyOn(clack, 'select').mockResolvedValue('anthropic/claude-sonnet-4-6')
+
+      const result = await promptForModel(['anthropic', 'openai'])
+
+      expect(result).toBe('anthropic/claude-sonnet-4-6')
+
+      selectSpy.mockRestore()
+    })
+
+    it('happy path: operator picks "enter custom..." then types openai/gpt-5.4-mini', async () => {
+      const clack = await import('@clack/prompts')
+      const selectSpy = spyOn(clack, 'select').mockResolvedValue('__custom__')
+      const textSpy = spyOn(clack, 'text').mockResolvedValue('openai/gpt-5.4-mini')
+
+      const result = await promptForModel(['anthropic', 'openai'])
+
+      expect(result).toBe('openai/gpt-5.4-mini')
+      expect(textSpy).toHaveBeenCalledTimes(1)
+
+      selectSpy.mockRestore()
+      textSpy.mockRestore()
+    })
+
+    it('edge case: custom model entry fails regex then succeeds on second attempt', async () => {
+      const clack = await import('@clack/prompts')
+      const selectSpy = spyOn(clack, 'select').mockResolvedValue('__custom__')
+      let textCallCount = 0
+      const textSpy = spyOn(clack, 'text').mockImplementation(
+        asTextImpl(async () => {
+          textCallCount++
+          // Simulate the validate function being called inline by the mock
+          // The real clack text prompt calls validate internally; here we just
+          // return the value and let the helper's validate logic re-prompt.
+          // Since we can't simulate clack's internal validate loop, we test
+          // that the helper's validate function rejects bad input.
+          if (textCallCount === 1) {
+            // Return a bad value — the helper should detect this and re-prompt
+            return 'bad-model'
+          }
+          return 'openai/gpt-5.4-mini'
+        }),
+      )
+
+      const result = await promptForModel(['anthropic', 'openai'])
+
+      expect(result).toBe('openai/gpt-5.4-mini')
+      expect(textSpy.mock.calls.length).toBeGreaterThanOrEqual(1)
+
+      selectSpy.mockRestore()
+      textSpy.mockRestore()
+    })
+
+    it('edge case: cancel during model select causes process.exit(0)', async () => {
+      const clack = await import('@clack/prompts')
+      const cancelSymbol = Symbol('cancel')
+      const selectSpy = spyOn(clack, 'select').mockResolvedValue(cancelSymbol)
+      const isCancelSpy = spyOn(clack, 'isCancel').mockImplementation(v => v === cancelSymbol)
+      const cancelSpy = spyOn(clack, 'cancel').mockImplementation(() => {})
+      const exitSpy = spyOn(process, 'exit').mockImplementation((_code?: number): never => {
+        throw new Error('process.exit called')
+      })
+
+      await expect(promptForModel(['anthropic', 'openai'])).rejects.toThrow('process.exit called')
+
+      selectSpy.mockRestore()
+      isCancelSpy.mockRestore()
+      cancelSpy.mockRestore()
+      exitSpy.mockRestore()
+    })
+  })
+})