@marcusrbrown/infra 0.13.1 → 0.13.2

package/src/commands/cliproxy/config.ts

@@ -1,238 +0,0 @@
-import type {goke} from 'goke'
-
-import type {ActionCtx} from '../../lib/action-ctx'
-import {chmodSync} from 'node:fs'
-
-import {z} from 'zod'
-
-import {managementHeaders, requestJson} from './shared'
-
-/** Minimal ctx surface consumed by cliproxy config actions. Satisfied by both GokeExecutionContext and CapturedCtx. */
-// ActionCtx imported from lib/action-ctx — single source of truth for action ctx shape
-
-const DEFAULT_CLIPROXY_URL = 'https://cliproxy.fro.bot'
-
-function stripTrailingSlash(value: string): string {
-  return value.endsWith('/') ? value.slice(0, -1) : value
-}
-
-function resolveBaseUrl(input?: string): string {
-  return stripTrailingSlash(input ?? process.env.CLIPROXY_URL ?? DEFAULT_CLIPROXY_URL)
-}
-
-export function resolveManagementKey(input?: string): string {
-  const key = input ?? process.env.CLIPROXY_MANAGEMENT_KEY
-
-  if (!key) {
-    throw new Error('Management API key is required. Pass --key or set CLIPROXY_MANAGEMENT_KEY.')
-  }
-
-  return key
-}
-
-export function parseBoolean(value: string): boolean {
-  const normalized = value.toLowerCase()
-  if (normalized === 'true') {
-    return true
-  }
-
-  if (normalized === 'false') {
-    return false
-  }
-
-  throw new Error(`Expected a boolean value (true/false), got: "${value}"`)
-}
-
-export function parseNumber(value: string, field: string): number {
-  const parsed = Number(value)
-  if (!Number.isFinite(parsed)) {
-    throw new TypeError(`${field} expects a numeric value, got: "${value}"`)
-  }
-
-  return parsed
-}
-
-type FieldType = 'boolean' | 'number' | 'string'
-
-interface FieldSpec {
-  path: string
-  type: FieldType
-}
-
-const MUTABLE_FIELDS: Record<string, FieldSpec> = {
-  debug: {path: '/debug', type: 'boolean'},
-  'request-retry': {path: '/request-retry', type: 'number'},
-  'max-retry-interval': {path: '/max-retry-interval', type: 'number'},
-  'proxy-url': {path: '/proxy-url', type: 'string'},
-  'request-log': {path: '/request-log', type: 'boolean'},
-  'ws-auth': {path: '/ws-auth', type: 'boolean'},
-  'logging-to-file': {path: '/logging-to-file', type: 'boolean'},
-  'usage-statistics-enabled': {path: '/usage-statistics-enabled', type: 'boolean'},
-  'force-model-prefix': {path: '/force-model-prefix', type: 'boolean'},
-}
-
-export function buildSetRequest(baseUrl: string, field: string, rawValue: string): {endpoint: string; body: string} {
-  const spec = MUTABLE_FIELDS[field]
-  if (!spec) {
-    const supported = Object.keys(MUTABLE_FIELDS).join(', ')
-    throw new Error(`"${field}" is not a supported mutable field. Supported: ${supported}`)
-  }
-
-  let value: boolean | number | string
-  if (spec.type === 'boolean') {
-    value = parseBoolean(rawValue)
-  } else if (spec.type === 'number') {
-    value = parseNumber(rawValue, field)
-  } else {
-    value = rawValue
-  }
-
-  return {
-    endpoint: `${baseUrl}/v0/management${spec.path}`,
-    body: JSON.stringify({value}),
-  }
-}
-
-export function formatConfigAsColumns(payload: unknown): string {
-  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-    return JSON.stringify(payload, null, 2)
-  }
-
-  const entries = Object.entries(payload as Record<string, unknown>)
-  if (entries.length === 0) {
-    return ''
-  }
-
-  const maxKeyLength = Math.max(...entries.map(([k]) => k.length))
-  return entries
-    .map(([key, value]) => {
-      const paddedKey = key.padEnd(maxKeyLength)
-      const displayValue = typeof value === 'object' ? JSON.stringify(value) : String(value)
-      return `${paddedKey}: ${displayValue}`
-    })
-    .join('\n')
-}
-
-export interface ConfigGetOptions {
-  url?: string
-  key?: string
-  output?: string
-  json?: boolean
-}
-
-export async function cliproxyConfigGetAction(options: ConfigGetOptions, ctx: ActionCtx): Promise<unknown> {
-  try {
-    const baseUrl = resolveBaseUrl(options.url)
-    const managementKey = resolveManagementKey(options.key)
-    const endpoint = `${baseUrl}/v0/management/config`
-    const payload = await requestJson(endpoint, {
-      method: 'GET',
-      headers: managementHeaders(managementKey),
-    })
-
-    const jsonOutput = JSON.stringify(payload, null, 2)
-
-    if (options.output) {
-      try {
-        await Bun.write(options.output, jsonOutput)
-        chmodSync(options.output, 0o600)
-        ctx.console.log(`✓ Config written to ${options.output}`)
-      } catch (error: unknown) {
-        const message = error instanceof Error ? error.message : String(error)
-        ctx.console.error(`Failed to write config to ${options.output}: ${message}`)
-        ctx.process.exit(1)
-        return undefined // unreachable
-      }
-    } else if (options.json) {
-      ctx.console.error('⚠️  Output may contain API keys — avoid logging or storing in shared locations')
-      ctx.console.log(jsonOutput)
-    } else {
-      ctx.console.error('⚠️  Output may contain API keys — avoid logging or storing in shared locations')
-      ctx.console.log(formatConfigAsColumns(payload))
-    }
-
-    return payload
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    ctx.console.error(message)
-    ctx.process.exit(1)
-    return undefined // unreachable; satisfies TS that all paths return
-  }
-}
-
-export interface ConfigSetOptions {
-  url?: string
-  key?: string
-}
-
-export async function cliproxyConfigSetAction(
-  field: string,
-  value: string,
-  options: ConfigSetOptions,
-  ctx: ActionCtx,
-): Promise<void> {
-  try {
-    const baseUrl = resolveBaseUrl(options.url)
-    const managementKey = resolveManagementKey(options.key)
-    const request = buildSetRequest(baseUrl, field, value)
-
-    const payload = await requestJson(request.endpoint, {
-      method: 'PUT',
-      headers: managementHeaders(managementKey),
-      body: request.body,
-    })
-
-    ctx.console.log(JSON.stringify(payload, null, 2))
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error)
-    ctx.console.error(message)
-    ctx.process.exit(1)
-  }
-}
-
-export function registerCliproxyConfig(cli: ReturnType<typeof goke>): void {
-  cli
-    .command('cliproxy config get', 'Fetch current CLIProxyAPI config as JSON.')
-    .option(
-      '--url [url]',
-      z
-        .string()
-        .describe(
-          'Base URL for CLIProxyAPI management requests. Falls back to CLIPROXY_URL or https://cliproxy.fro.bot.',
-        ),
-    )
-    .option(
-      '--key [key]',
-      z.string().describe('Management API key. Falls back to CLIPROXY_MANAGEMENT_KEY when omitted.'),
-    )
-    .option(
-      '--output [file]',
-      z
-        .string()
-        .describe('Write config JSON to a file instead of stdout. File permissions set to 0600 (owner-read-only).'),
-    )
-    .option('--json', 'Output raw JSON instead of aligned key: value columns.')
-    .action(cliproxyConfigGetAction)
-
-  cli
-    .command(
-      'cliproxy config set <field> <value>',
-      'Update a mutable CLIProxyAPI config field via its dedicated management endpoint.',
-    )
-    .option(
-      '--url [url]',
-      z
-        .string()
-        .describe(
-          'Base URL for CLIProxyAPI management requests. Falls back to CLIPROXY_URL or https://cliproxy.fro.bot.',
-        ),
-    )
-    .option(
-      '--key [key]',
-      z.string().describe('Management API key. Falls back to CLIPROXY_MANAGEMENT_KEY when omitted.'),
-    )
-    .example('infra cliproxy config set debug true')
-    .example('infra cliproxy config set request-retry 5')
-    .example('infra cliproxy config set proxy-url https://proxy.example.com')
-    .action(cliproxyConfigSetAction)
-}

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

@@ -1,181 +0,0 @@
-import {resolve} from 'node:path'
-import {afterEach, beforeEach, describe, expect, it, spyOn} from 'bun:test'
-
-import {getLocalDeployEnv, resolveLocalDeployScriptPath, validateRemotePreconditions} from './deploy'
-
-const cliDir = resolve(import.meta.dir, '../../..')
-
-const envKeys = ['CLIPROXY_DOMAIN', 'CLIPROXY_MANAGEMENT_KEY', 'HOME', 'PATH', 'SSH_AUTH_SOCK'] as const
-
-type ManagedEnvKey = (typeof envKeys)[number]
-
-let originalEnv: Partial<Record<ManagedEnvKey, string | undefined>>
-
-function restoreManagedEnv(): void {
-  for (const key of envKeys) {
-    const value = originalEnv[key]
-
-    if (value === undefined) {
-      delete process.env[key]
-      continue
-    }
-
-    process.env[key] = value
-  }
-}
-
-function setManagedEnv(overrides: Partial<Record<ManagedEnvKey, string | undefined>>): void {
-  restoreManagedEnv()
-
-  for (const [key, value] of Object.entries(overrides)) {
-    if (value === undefined) {
-      delete process.env[key]
-      continue
-    }
-
-    process.env[key as ManagedEnvKey] = value
-  }
-}
-
-async function runDeployCommand(
-  args: string[],
-  envOverrides: Partial<Record<ManagedEnvKey, string | undefined>> = {},
-): Promise<{stdout: string; stderr: string; exitCode: number}> {
-  const env = {...process.env}
-
-  for (const [key, value] of Object.entries(envOverrides)) {
-    if (value === undefined) {
-      delete env[key]
-      continue
-    }
-
-    env[key] = value
-  }
-
-  const proc = Bun.spawn(['bun', 'src/cli.ts', 'cliproxy', 'deploy', ...args], {
-    cwd: cliDir,
-    env: {
-      ...env,
-      HOME: env.HOME ?? '/tmp/test-home',
-      NO_COLOR: '1',
-      PATH: env.PATH ?? '/usr/bin:/bin',
-      SSH_AUTH_SOCK: env.SSH_AUTH_SOCK ?? '/tmp/test-sock',
-    },
-    stdout: 'pipe',
-    stderr: 'pipe',
-  })
-
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ])
-
-  return {stdout, stderr, exitCode}
-}
-
-describe('cliproxy deploy', () => {
-  beforeEach(() => {
-    originalEnv = Object.fromEntries(envKeys.map(key => [key, process.env[key]]))
-  })
-
-  afterEach(() => {
-    restoreManagedEnv()
-  })
-
-  describe('resolveLocalDeployScriptPath', () => {
-    it('returns a string path containing deploy.ts', () => {
-      const deployScriptPath = resolveLocalDeployScriptPath()
-
-      expect(typeof deployScriptPath).toBe('string')
-      expect(deployScriptPath).toContain('deploy.ts')
-    })
-  })
-
-  describe('getLocalDeployEnv', () => {
-    it('returns the expected deploy environment when required variables are present', () => {
-      setManagedEnv({
-        CLIPROXY_DOMAIN: 'cliproxy.example.com',
-        CLIPROXY_MANAGEMENT_KEY: 'test-management-key',
-        HOME: '/tmp/test-home',
-        PATH: '/usr/bin:/bin',
-        SSH_AUTH_SOCK: '/tmp/test-sock',
-      })
-
-      expect(getLocalDeployEnv()).toEqual({
-        CLIPROXY_DOMAIN: 'cliproxy.example.com',
-        CLIPROXY_MANAGEMENT_KEY: 'test-management-key',
-        HOME: '/tmp/test-home',
-        PATH: '/usr/bin:/bin',
-        SSH_AUTH_SOCK: '/tmp/test-sock',
-      })
-    })
-
-    it('throws when PATH is missing', () => {
-      setManagedEnv({
-        HOME: '/tmp/test-home',
-        PATH: undefined,
-        SSH_AUTH_SOCK: '/tmp/test-sock',
-      })
-
-      expect(() => getLocalDeployEnv()).toThrow(/PATH/)
-    })
-
-    it('throws when HOME is missing', () => {
-      setManagedEnv({
-        HOME: undefined,
-        PATH: '/usr/bin:/bin',
-        SSH_AUTH_SOCK: '/tmp/test-sock',
-      })
-
-      expect(() => getLocalDeployEnv()).toThrow(/HOME/)
-    })
-
-    it('throws when SSH_AUTH_SOCK is missing', () => {
-      setManagedEnv({
-        HOME: '/tmp/test-home',
-        PATH: '/usr/bin:/bin',
-        SSH_AUTH_SOCK: undefined,
-      })
-
-      expect(() => getLocalDeployEnv()).toThrow(/SSH_AUTH_SOCK/)
-    })
-  })
-
-  describe('validateRemotePreconditions', () => {
-    it('does not throw when gh is available', () => {
-      const whichSpy = spyOn(Bun, 'which').mockReturnValue('/opt/homebrew/bin/gh')
-
-      expect(() => validateRemotePreconditions()).not.toThrow()
-
-      whichSpy.mockRestore()
-    })
-
-    it('throws when gh is unavailable', () => {
-      const whichSpy = spyOn(Bun, 'which').mockReturnValue(null)
-
-      expect(() => validateRemotePreconditions()).toThrow(/gh CLI is required/)
-
-      whichSpy.mockRestore()
-    })
-  })
-
-  describe('CLI flag interactions', () => {
-    it('prints the local dry-run plan', async () => {
-      const deployScriptPath = resolveLocalDeployScriptPath()
-      const {stdout, stderr, exitCode} = await runDeployCommand(['--local', '--dry-run'])
-
-      expect(exitCode).toBe(0)
-      expect(stderr).toBe('')
-      expect(stdout).toContain('Dry run: local CLIProxyAPI deploy')
-      expect(stdout).toContain(deployScriptPath)
-      expect(stdout).toContain('CLIPROXY_DOMAIN=')
-    })
-
-    it('rejects invalid options with a non-zero exit code', async () => {
-      const {exitCode} = await runDeployCommand(['--bogus'])
-
-      expect(exitCode).not.toBe(0)
-    })
-  })
-})

package/src/commands/cliproxy/deploy.ts

@@ -1,157 +0,0 @@
-import type {goke} from 'goke'
-
-import {existsSync} from 'node:fs'
-import {resolve} from 'node:path'
-import {z} from 'zod'
-
-const REPO = 'marcusrbrown/infra'
-const WORKFLOW_NAME = 'Deploy CLIProxy'
-const WORKFLOW_URL = 'https://github.com/marcusrbrown/infra/actions/workflows/deploy-cliproxy.yaml'
-
-type CliInstance = ReturnType<typeof goke>
-
-export function resolveLocalDeployScriptPath(): string {
-  const primary = resolve(import.meta.dir, '../../../../../apps/cliproxy/src/deploy.ts')
-  if (existsSync(primary)) {
-    return primary
-  }
-
-  return resolve(import.meta.dir, '../../../../apps/cliproxy/src/deploy.ts')
-}
-
-export function getLocalDeployEnv(): Record<string, string> {
-  const path = process.env.PATH
-  const home = process.env.HOME
-  const sshAuthSock = process.env.SSH_AUTH_SOCK
-
-  if (!path) {
-    throw new Error('PATH is required for local deploy')
-  }
-
-  if (!home) {
-    throw new Error('HOME is required for local deploy')
-  }
-
-  if (!sshAuthSock) {
-    throw new Error('SSH_AUTH_SOCK is required for local deploy. Start ssh-agent and load your deploy key first.')
-  }
-
-  return {
-    PATH: path,
-    HOME: home,
-    SSH_AUTH_SOCK: sshAuthSock,
-    CLIPROXY_DOMAIN: process.env.CLIPROXY_DOMAIN ?? '',
-    CLIPROXY_MANAGEMENT_KEY: process.env.CLIPROXY_MANAGEMENT_KEY ?? '',
-  }
-}
-
-export function validateLocalPreconditions(): {deployScriptPath: string} {
-  const deployScriptPath = resolveLocalDeployScriptPath()
-  if (!existsSync(deployScriptPath)) {
-    throw new Error(`Local deploy script not found at expected path: ${deployScriptPath}`)
-  }
-
-  getLocalDeployEnv()
-
-  return {deployScriptPath}
-}
-
-export function validateRemotePreconditions(): void {
-  if (!Bun.which('gh')) {
-    throw new Error('gh CLI is required for remote deploy. Install gh and run `gh auth login`.')
-  }
-}
-
-export function registerCliproxyDeploy(cli: CliInstance): void {
-  cli
-    .command(
-      'cliproxy deploy',
-      'Deploy CLIProxyAPI. Default mode triggers the GitHub Deploy CLIProxy workflow, while --local runs apps/cliproxy/src/deploy.ts directly with Bun.',
-    )
-    .option(
-      '--local',
-      z
-        .boolean()
-        .default(false)
-        .describe(
-          'Run local deployment with Bun using apps/cliproxy/src/deploy.ts instead of triggering GitHub Actions.',
-        ),
-    )
-    .option(
-      '--force-config',
-      z
-        .boolean()
-        .default(false)
-        .describe(
-          'Force upload config.yaml even if it exists on the server. WARNING: overwrites runtime API keys and settings.',
-        ),
-    )
-    .option(
-      '--dry-run',
-      z
-        .boolean()
-        .default(false)
-        .describe(
-          'Validate deploy prerequisites and print planned actions without executing local deploy or dispatching workflow.',
-        ),
-    )
-    .example('# Trigger remote GitHub Actions deploy (default mode)')
-    .example('infra cliproxy deploy')
-    .example('# Validate local deploy preconditions and planned command')
-    .example('infra cliproxy deploy --local --dry-run')
-    .example('# Run local deploy with explicit SSH agent context')
-    .example('infra cliproxy deploy --local')
-    .action(async options => {
-      if (options.local) {
-        const {deployScriptPath} = validateLocalPreconditions()
-        const env = getLocalDeployEnv()
-        const command = ['bun', deployScriptPath, ...(options.forceConfig ? ['--force-config'] : [])]
-
-        if (options.dryRun) {
-          console.log('Dry run: local CLIProxyAPI deploy')
-          console.log(`- deploy script: ${deployScriptPath}`)
-          console.log(`- command: ${command.join(' ')}`)
-          if (options.forceConfig) {
-            console.log('- WARNING: --force-config will overwrite server config.yaml (wipes API keys)')
-          }
-          console.log(`- CLIPROXY_DOMAIN=${env.CLIPROXY_DOMAIN || '(unset)'}`)
-          return
-        }
-
-        const child = Bun.spawn(command, {
-          env,
-          stdout: 'inherit',
-          stderr: 'inherit',
-        })
-
-        const exitCode = await child.exited
-        if (exitCode !== 0) {
-          throw new Error(`Local deploy failed with exit code ${exitCode}`)
-        }
-
-        return
-      }
-
-      validateRemotePreconditions()
-
-      if (options.dryRun) {
-        console.log('Dry run: remote CLIProxyAPI deploy')
-        console.log(`- command: gh workflow run ${WORKFLOW_NAME} --repo ${REPO}`)
-        console.log(`- workflow URL: ${WORKFLOW_URL}`)
-        return
-      }
-
-      const child = Bun.spawn(['gh', 'workflow', 'run', WORKFLOW_NAME, '--repo', REPO], {
-        stdout: 'inherit',
-        stderr: 'inherit',
-      })
-
-      const exitCode = await child.exited
-      if (exitCode !== 0) {
-        throw new Error(`Failed to trigger ${WORKFLOW_NAME} workflow (exit code ${exitCode})`)
-      }
-
-      console.log(`Workflow triggered: ${WORKFLOW_URL}`)
-      console.log('Approve the cliproxy environment deployment in GitHub Actions to continue.')
-    })
-}

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

@@ -1,73 +0,0 @@
-import {describe, expect, it} from 'bun:test'
-
-import {validateCliproxyHost} from './host'
-
-// ─── validateCliproxyHost ─────────────────────────────────────────────────────
-
-describe('validateCliproxyHost', () => {
-  // ── Valid inputs ────────────────────────────────────────────────────────────
-
-  it('accepts a standard FQDN', () => {
-    expect(() => validateCliproxyHost('cliproxy.fro.bot')).not.toThrow()
-    expect(validateCliproxyHost('cliproxy.fro.bot')).toBe('cliproxy.fro.bot')
-  })
-
-  it('accepts localhost', () => {
-    expect(() => validateCliproxyHost('localhost')).not.toThrow()
-  })
-
-  it('accepts an IPv4 address', () => {
-    expect(() => validateCliproxyHost('147.182.133.210')).not.toThrow()
-  })
-
-  it('accepts a single-character hostname', () => {
-    expect(() => validateCliproxyHost('a')).not.toThrow()
-  })
-
-  it('accepts a hostname with hyphens', () => {
-    expect(() => validateCliproxyHost('my-cliproxy.prod.example.com')).not.toThrow()
-  })
-
-  // ── Injection attacks ───────────────────────────────────────────────────────
-
-  it('rejects a leading-hyphen value (ProxyCommand injection vector)', () => {
-    expect(() => validateCliproxyHost('-oProxyCommand=evil')).toThrow('Invalid CLIPROXY_DOMAIN')
-  })
-
-  it('rejects a value with shell metacharacters (semicolon)', () => {
-    expect(() => validateCliproxyHost('cliproxy.fro.bot;rm -rf')).toThrow('Invalid CLIPROXY_DOMAIN')
-  })
-
-  it('rejects a value with shell metacharacters (backtick)', () => {
-    expect(() => validateCliproxyHost('cliproxy.fro.bot`id`')).toThrow('Invalid CLIPROXY_DOMAIN')
-  })
-
-  it('rejects a value with spaces', () => {
-    expect(() => validateCliproxyHost('cliproxy fro.bot')).toThrow('Invalid CLIPROXY_DOMAIN')
-  })
-
-  it('rejects a value with an at-sign', () => {
-    expect(() => validateCliproxyHost('user@cliproxy.fro.bot')).toThrow('Invalid CLIPROXY_DOMAIN')
-  })
-
-  // ── Empty / blank ───────────────────────────────────────────────────────────
-
-  it('rejects an empty string', () => {
-    expect(() => validateCliproxyHost('')).toThrow('Invalid CLIPROXY_DOMAIN')
-  })
-
-  // ── Error message sanitization ──────────────────────────────────────────────
-
-  it('truncates the invalid value in the error message to ~30 chars', () => {
-    const longMalicious = `-oProxyCommand=${'A'.repeat(100)}`
-    let message = ''
-    try {
-      validateCliproxyHost(longMalicious)
-    } catch (error) {
-      message = error instanceof Error ? error.message : String(error)
-    }
-    // The excerpt in the message should not exceed 30 chars of the original value
-    expect(message).toContain('Invalid CLIPROXY_DOMAIN')
-    expect(message.length).toBeLessThan(longMalicious.length + 50)
-  })
-})

package/src/commands/cliproxy/host.ts

@@ -1,31 +0,0 @@
-// ─── Cliproxy host validation ─────────────────────────────────────────────────
-//
-// Validates CLIPROXY_DOMAIN values before they are passed as ssh argv arguments.
-// A value starting with `-` would be interpreted by ssh as an option flag,
-// enabling ProxyCommand injection and local code execution.
-
-const VALID_HOST_RE = /^[a-z\d][a-z\d.\-]*$/i
-
-/**
- * Validates a candidate CLIPROXY_DOMAIN value against a strict hostname allowlist.
- *
- * Accepts: hostnames, FQDNs, IPv4 addresses, `localhost`.
- * Rejects: empty strings, values starting with `-`, and anything containing
- * characters outside `[A-Za-z0-9.-]`.
- *
- * @throws {Error} with a sanitized excerpt of the invalid value.
- * @returns The validated host string (unchanged).
- */
-export function validateCliproxyHost(host: string): string {
-  if (!host) {
-    throw new Error('Invalid CLIPROXY_DOMAIN: value is empty')
-  }
-
-  if (!VALID_HOST_RE.test(host)) {
-    // Truncate to 30 chars and strip non-printable bytes before echoing back
-    const excerpt = host.slice(0, 30).replaceAll(/[^\u0020-\u007E]/g, '?')
-    throw new Error(`Invalid CLIPROXY_DOMAIN: "${excerpt}" — must match ${String.raw`[A-Za-z0-9][A-Za-z0-9.\-]*`}`)
-  }
-
-  return host
-}