@marcusrbrown/infra 0.13.0 → 0.13.2

package/src/commands/status.test.ts

@@ -1,222 +0,0 @@
-import type {StatusSummary} from './status'
-import {describe, expect, it} from 'bun:test'
-import {goke} from 'goke'
-import {createCapturedCtx, expectCapturedToInclude} from '../__test__/mcp-ctx-fixture'
-import {registerStatus, unifiedStatusAction} from './status'
-
-// NOTE: dashboard is included in the unified status table alongside the other apps.
-
-const healthyKeeweb: StatusSummary = {
-  app: 'keeweb',
-  http: 'OK',
-  lastDeploy: '2026-04-12 10:00',
-  version: '—',
-  contentHash: 'match',
-  usageStats: '—',
-}
-
-const healthyCliproxy: StatusSummary = {
-  app: 'cliproxy',
-  http: 'OK',
-  lastDeploy: '—',
-  version: 'v1.2.3',
-  contentHash: '—',
-  usageStats: '12 req / 0 fail',
-}
-
-const healthyGateway: StatusSummary = {
-  app: 'gateway',
-  http: 'OK: gateway:running/healthy',
-  lastDeploy: '—',
-  version: '—',
-  contentHash: '—',
-  usageStats: '—',
-}
-
-const healthyUmami: StatusSummary = {
-  app: 'umami',
-  http: 'OK: umami:running/healthy',
-  lastDeploy: '—',
-  version: '—',
-  contentHash: '—',
-  usageStats: '—',
-}
-
-const healthyVpn: StatusSummary = {
-  app: 'vpn',
-  http: 'OK: wg0 up, pubkey:TESTKEY== 1 peer(s)',
-  lastDeploy: '—',
-  version: '—',
-  contentHash: '—',
-  usageStats: '—',
-}
-
-const healthyDashboard: StatusSummary = {
-  app: 'dashboard',
-  http: 'OK: dashboard:running/healthy',
-  lastDeploy: '—',
-  version: '—',
-  contentHash: '—',
-  usageStats: '—',
-}
-
-function makeDeps(overrides?: Partial<Parameters<typeof registerStatus>[1]>): Parameters<typeof registerStatus>[1] {
-  return {
-    getKeewebStatusSummary: async () => healthyKeeweb,
-    getCliproxyStatusSummary: async () => healthyCliproxy,
-    getGatewayStatusSummary: async () => healthyGateway,
-    getUmamiStatusSummary: async () => healthyUmami,
-    getDashboardStatusSummary: async () => healthyDashboard,
-    getVpnStatusSummary: async () => healthyVpn,
-    ...overrides,
-  }
-}
-
-describe('top-level status command (Tier-2 ctx capture)', () => {
-  it('prints a unified table when all apps are healthy', async () => {
-    const {ctx, captured} = createCapturedCtx()
-
-    await unifiedStatusAction({}, ctx, makeDeps())
-
-    expect(
-      expectCapturedToInclude(captured, '| App | HTTP | Last Deploy | Version | Content Hash | Usage Stats |'),
-    ).toBe(true)
-    expect(expectCapturedToInclude(captured, '| keeweb | OK | 2026-04-12 10:00 | — | match | — |')).toBe(true)
-    expect(expectCapturedToInclude(captured, '| cliproxy | OK | — | v1.2.3 | — | 12 req / 0 fail |')).toBe(true)
-    expect(expectCapturedToInclude(captured, '| gateway | OK: gateway:running/healthy | — | — | — | — |')).toBe(true)
-    expect(expectCapturedToInclude(captured, '| umami | OK: umami:running/healthy | — | — | — | — |')).toBe(true)
-    expect(expectCapturedToInclude(captured, '| dashboard | OK: dashboard:running/healthy | — | — | — | — |')).toBe(
-      true,
-    )
-    expect(expectCapturedToInclude(captured, '| vpn | OK: wg0 up, pubkey:TESTKEY== 1 peer(s) | — | — | — | — |')).toBe(
-      true,
-    )
-  })
-
-  it('includes a vpn row sourced from getVpnStatusSummary()', async () => {
-    const {ctx, captured} = createCapturedCtx()
-
-    await unifiedStatusAction({}, ctx, makeDeps())
-
-    // The vpn row must appear in the table output
-    expect(expectCapturedToInclude(captured, '| vpn |')).toBe(true)
-  })
-
-  it('shows an error row for vpn when getVpnStatusSummary rejects', async () => {
-    const {ctx, captured} = createCapturedCtx()
-
-    await unifiedStatusAction(
-      {},
-      ctx,
-      makeDeps({
-        getVpnStatusSummary: async () => {
-          throw new Error('VPN_HOST not set')
-        },
-      }),
-    )
-
-    expect(
-      expectCapturedToInclude(
-        captured,
-        '| vpn | ❌ VPN_HOST not set | ❌ VPN_HOST not set | ❌ VPN_HOST not set | ❌ VPN_HOST not set | ❌ VPN_HOST not set |',
-      ),
-    ).toBe(true)
-    expect(captured.stderr.join('')).toContain('vpn status check failed: VPN_HOST not set')
-  })
-
-  it('shows an error row when umami is unreachable and keeps the other results', async () => {
-    const {ctx, captured} = createCapturedCtx()
-
-    await unifiedStatusAction(
-      {},
-      ctx,
-      makeDeps({
-        getUmamiStatusSummary: async () => {
-          throw new Error('UMAMI_DOMAIN not set')
-        },
-      }),
-    )
-
-    expect(
-      expectCapturedToInclude(
-        captured,
-        '| umami | ❌ UMAMI_DOMAIN not set | ❌ UMAMI_DOMAIN not set | ❌ UMAMI_DOMAIN not set | ❌ UMAMI_DOMAIN not set | ❌ UMAMI_DOMAIN not set |',
-      ),
-    ).toBe(true)
-    expect(expectCapturedToInclude(captured, '| gateway | OK: gateway:running/healthy | — | — | — | — |')).toBe(true)
-    expect(captured.stderr.join('')).toContain('umami status check failed: UMAMI_DOMAIN not set')
-  })
-
-  it('shows an error row when one app fails and keeps the other results', async () => {
-    const {ctx, captured} = createCapturedCtx()
-
-    await unifiedStatusAction(
-      {},
-      ctx,
-      makeDeps({
-        getKeewebStatusSummary: async () => {
-          throw new Error('Keeweb exploded')
-        },
-      }),
-    )
-
-    expect(
-      expectCapturedToInclude(
-        captured,
-        '| keeweb | ❌ Keeweb exploded | ❌ Keeweb exploded | ❌ Keeweb exploded | ❌ Keeweb exploded | ❌ Keeweb exploded |',
-      ),
-    ).toBe(true)
-    expect(expectCapturedToInclude(captured, '| cliproxy | OK | — | v1.2.3 | — | 12 req / 0 fail |')).toBe(true)
-    // Rejection reason must also appear in stderr so MCP consumers can see it
-    expect(captured.stderr.join('')).toContain('keeweb status check failed: Keeweb exploded')
-  })
-
-  it('prints valid json with all app keys when --json is passed', async () => {
-    const {ctx, captured} = createCapturedCtx()
-
-    await unifiedStatusAction({json: true}, ctx, makeDeps())
-
-    expect(captured.stdout).toHaveLength(1)
-
-    const [jsonOutput] = captured.stdout
-    expect(jsonOutput).toBeDefined()
-
-    const parsed = JSON.parse(jsonOutput ?? '{}') as {
-      keeweb: {http: string}
-      cliproxy: {version: string}
-      gateway: {http: string}
-      umami: {http: string}
-      dashboard: {http: string}
-      vpn: {http: string}
-    }
-
-    expect(parsed.keeweb.http).toBe('OK')
-    expect(parsed.cliproxy.version).toBe('v1.2.3')
-    expect(parsed.gateway.http).toBe('OK: gateway:running/healthy')
-    expect(parsed.umami.http).toBe('OK: umami:running/healthy')
-    expect(parsed.dashboard.http).toBe('OK: dashboard:running/healthy')
-    expect(parsed.vpn.http).toBe('OK: wg0 up, pubkey:TESTKEY== 1 peer(s)')
-  })
-
-  it('does not write to global console (output is captured via ctx)', async () => {
-    const {ctx, captured} = createCapturedCtx()
-
-    await unifiedStatusAction({}, ctx, makeDeps())
-
-    // Verify output went to ctx capture, not global console
-    expect(captured.stdout.length).toBeGreaterThan(0)
-    expect(expectCapturedToInclude(captured, '| App |')).toBe(true)
-  })
-})
-
-describe('top-level status command (registerStatus wiring)', () => {
-  it('wires through goke without throwing', async () => {
-    const cli = goke('test')
-
-    registerStatus(cli, makeDeps())
-    cli.parse(['bun', 'test', 'status'], {run: false})
-
-    // Verify the command runs without throwing (goke uses its own ctx for output)
-    await expect(cli.runMatchedCommand()).resolves.toBeUndefined()
-  })
-})

package/src/commands/status.ts

@@ -1,161 +0,0 @@
-import type {goke} from 'goke'
-
-import type {ActionCtx} from '../lib/action-ctx'
-
-import {z} from 'zod'
-
-import {getCliproxyStatusSummary} from './cliproxy/status'
-import {getDashboardStatusSummary} from './dashboard'
-import {getGatewayStatusSummary} from './gateway'
-import {getKeewebStatusSummary} from './keeweb/status'
-import {getUmamiStatusSummary} from './umami'
-import {getVpnStatusSummary} from './vpn'
-
-declare const process: {
-  env: Record<string, string | undefined>
-}
-
-export interface StatusSummary {
-  app: 'keeweb' | 'cliproxy' | 'gateway' | 'umami' | 'dashboard' | 'vpn'
-  http: string
-  lastDeploy: string
-  version: string
-  contentHash: string
-  usageStats: string
-}
-
-type AppName = StatusSummary['app']
-
-interface StatusDependencies {
-  getKeewebStatusSummary: (verbose: boolean) => Promise<StatusSummary>
-  getCliproxyStatusSummary: (baseUrl: string, key: string, verbose: boolean) => Promise<StatusSummary>
-  getGatewayStatusSummary: (host: string) => Promise<StatusSummary>
-  getUmamiStatusSummary: (host: string) => Promise<StatusSummary>
-  getDashboardStatusSummary: (host: string) => Promise<StatusSummary>
-  getVpnStatusSummary: (host: string) => Promise<StatusSummary>
-}
-
-const DEFAULT_CLIPROXY_URL = 'https://cliproxy.fro.bot'
-const ERROR_PREFIX = '❌'
-const TABLE_COLUMNS: {key: keyof StatusSummary; label: string}[] = [
-  {key: 'app', label: 'App'},
-  {key: 'http', label: 'HTTP'},
-  {key: 'lastDeploy', label: 'Last Deploy'},
-  {key: 'version', label: 'Version'},
-  {key: 'contentHash', label: 'Content Hash'},
-  {key: 'usageStats', label: 'Usage Stats'},
-]
-
-function stripTrailingSlash(value: string): string {
-  return value.endsWith('/') ? value.slice(0, -1) : value
-}
-
-function errorSummary(app: AppName, reason: unknown): StatusSummary {
-  const message = reason instanceof Error ? reason.message : String(reason)
-  const errorCell = `${ERROR_PREFIX} ${message}`
-
-  return {
-    app,
-    http: errorCell,
-    lastDeploy: errorCell,
-    version: errorCell,
-    contentHash: errorCell,
-    usageStats: errorCell,
-  }
-}
-
-function toJsonPayload(rows: StatusSummary[]): Record<AppName, StatusSummary> {
-  return {
-    keeweb: rows.find(row => row.app === 'keeweb') ?? errorSummary('keeweb', 'missing result'),
-    cliproxy: rows.find(row => row.app === 'cliproxy') ?? errorSummary('cliproxy', 'missing result'),
-    gateway: rows.find(row => row.app === 'gateway') ?? errorSummary('gateway', 'missing result'),
-    umami: rows.find(row => row.app === 'umami') ?? errorSummary('umami', 'missing result'),
-    dashboard: rows.find(row => row.app === 'dashboard') ?? errorSummary('dashboard', 'missing result'),
-    vpn: rows.find(row => row.app === 'vpn') ?? errorSummary('vpn', 'missing result'),
-  }
-}
-
-function formatRow(row: StatusSummary): string {
-  const values = TABLE_COLUMNS.map(({key}) => row[key])
-  return `| ${values.join(' | ')} |`
-}
-
-export async function unifiedStatusAction(
-  options: {json?: boolean; verbose?: boolean},
-  ctx: ActionCtx,
-  dependencies: StatusDependencies = {
-    getKeewebStatusSummary,
-    getCliproxyStatusSummary,
-    getGatewayStatusSummary,
-    getUmamiStatusSummary,
-    getDashboardStatusSummary,
-    getVpnStatusSummary,
-  },
-): Promise<void> {
-  const verbose = options.verbose === true
-  const cliproxyBaseUrl = stripTrailingSlash(process.env.CLIPROXY_URL ?? DEFAULT_CLIPROXY_URL)
-  const cliproxyKey = process.env.CLIPROXY_MANAGEMENT_KEY ?? ''
-  const gatewayHost = process.env.GATEWAY_HOST ?? ''
-  const umamiHost = process.env.UMAMI_DOMAIN ?? ''
-  const dashboardHost = process.env.DASHBOARD_DOMAIN ?? ''
-  const vpnHost = process.env.VPN_HOST ?? ''
-
-  const results = await Promise.allSettled([
-    dependencies.getKeewebStatusSummary(verbose),
-    dependencies.getCliproxyStatusSummary(cliproxyBaseUrl, cliproxyKey, verbose),
-    dependencies.getGatewayStatusSummary(gatewayHost),
-    dependencies.getUmamiStatusSummary(umamiHost),
-    dependencies.getDashboardStatusSummary(dashboardHost),
-    dependencies.getVpnStatusSummary(vpnHost),
-  ])
-
-  const appNames: AppName[] = ['keeweb', 'cliproxy', 'gateway', 'umami', 'dashboard', 'vpn']
-  const rows: StatusSummary[] = results.map((result, index) => {
-    const app = appNames[index] ?? 'keeweb'
-    if (result.status === 'fulfilled') {
-      return result.value
-    }
-    const reason = result.reason
-    const message = reason instanceof Error ? reason.message : String(reason)
-    ctx.console.error(`${app} status check failed: ${message}`)
-    return errorSummary(app, reason)
-  })
-
-  if (options.json === true) {
-    ctx.console.log(JSON.stringify(toJsonPayload(rows)))
-    return
-  }
-
-  ctx.console.log('| App | HTTP | Last Deploy | Version | Content Hash | Usage Stats |')
-  for (const row of rows) {
-    ctx.console.log(formatRow(row))
-  }
-}
-
-export function registerStatus(
-  cli: ReturnType<typeof goke>,
-  dependencies: StatusDependencies = {
-    getKeewebStatusSummary,
-    getCliproxyStatusSummary,
-    getGatewayStatusSummary,
-    getUmamiStatusSummary,
-    getDashboardStatusSummary,
-    getVpnStatusSummary,
-  },
-): void {
-  cli
-    .command('status', 'Show status of all deployments')
-    .option(
-      '--json',
-      z
-        .boolean()
-        .describe(
-          'Output machine-readable JSON with keeweb, cliproxy, gateway, umami, dashboard, and vpn summary objects.',
-        ),
-    )
-    .option(
-      '--verbose',
-      z.boolean().describe('Include verbose per-app health check details when building the summary rows.'),
-    )
-    .action((options, ctx) => unifiedStatusAction(options, ctx, dependencies))
-}

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

@@ -1,202 +0,0 @@
-import {resolve} from 'node:path'
-import {afterEach, beforeEach, describe, expect, it} from 'bun:test'
-
-import {getUmamiDeployEnv, validateUmamiRemotePreconditions} from './deploy'
-
-const repoRoot = resolve(import.meta.dir, '../../../../..')
-
-const envKeys = [
-  'HOME',
-  'PATH',
-  'SSH_AUTH_SOCK',
-  'UMAMI_DOMAIN',
-  'UMAMI_APP_SECRET',
-  'UMAMI_DB_PASSWORD',
-  'UMAMI_ADMIN_PASSWORD',
-  'UMAMI_SSH_KEY',
-] 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]
-    } else {
-      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 as ManagedEnvKey]
-    } else {
-      process.env[key as ManagedEnvKey] = value
-    }
-  }
-}
-
-beforeEach(() => {
-  originalEnv = {}
-  for (const key of envKeys) {
-    originalEnv[key] = process.env[key]
-  }
-})
-
-afterEach(() => {
-  restoreManagedEnv()
-})
-
-// ─── getUmamiDeployEnv ────────────────────────────────────────────────────────
-
-describe('getUmamiDeployEnv', () => {
-  it('returns env object with required keys when all are set', () => {
-    setManagedEnv({
-      PATH: '/usr/bin:/bin',
-      HOME: '/home/user',
-      SSH_AUTH_SOCK: '/tmp/ssh-agent.sock',
-      UMAMI_DOMAIN: 'metrics.fro.bot',
-    })
-
-    const env = getUmamiDeployEnv()
-
-    expect(env.PATH).toBe('/usr/bin:/bin')
-    expect(env.HOME).toBe('/home/user')
-    expect(env.SSH_AUTH_SOCK).toBe('/tmp/ssh-agent.sock')
-    expect(env.UMAMI_DOMAIN).toBe('metrics.fro.bot')
-  })
-
-  it('throws when PATH is missing', () => {
-    setManagedEnv({PATH: undefined, HOME: '/home/user', SSH_AUTH_SOCK: '/tmp/ssh-agent.sock'})
-
-    expect(() => getUmamiDeployEnv()).toThrow('PATH is required')
-  })
-
-  it('throws when HOME is missing', () => {
-    setManagedEnv({PATH: '/usr/bin:/bin', HOME: undefined, SSH_AUTH_SOCK: '/tmp/ssh-agent.sock'})
-
-    expect(() => getUmamiDeployEnv()).toThrow('HOME is required')
-  })
-
-  it('throws when SSH_AUTH_SOCK is missing and no UMAMI_SSH_KEY either', () => {
-    setManagedEnv({
-      PATH: '/usr/bin:/bin',
-      HOME: '/home/user',
-      SSH_AUTH_SOCK: undefined,
-      UMAMI_SSH_KEY: undefined,
-    })
-
-    expect(() => getUmamiDeployEnv()).toThrow('Local deploy needs an SSH context')
-  })
-
-  it('succeeds with only SSH_AUTH_SOCK set (no UMAMI_SSH_KEY)', () => {
-    setManagedEnv({
-      PATH: '/usr/bin:/bin',
-      HOME: '/home/user',
-      SSH_AUTH_SOCK: '/tmp/ssh-agent.sock',
-      UMAMI_SSH_KEY: undefined,
-    })
-
-    const env = getUmamiDeployEnv()
-
-    expect(env.SSH_AUTH_SOCK).toBe('/tmp/ssh-agent.sock')
-    expect('UMAMI_SSH_KEY' in env).toBe(false)
-  })
-
-  it('succeeds with only UMAMI_SSH_KEY set (no SSH_AUTH_SOCK) and includes the key in env', () => {
-    setManagedEnv({
-      PATH: '/usr/bin:/bin',
-      HOME: '/home/user',
-      SSH_AUTH_SOCK: undefined,
-      UMAMI_SSH_KEY: 'ssh-ed25519 AAAA...',
-    })
-
-    const env = getUmamiDeployEnv()
-
-    expect(env.UMAMI_SSH_KEY).toBe('ssh-ed25519 AAAA...')
-    expect('SSH_AUTH_SOCK' in env).toBe(false)
-  })
-
-  it('includes optional umami env vars when set', () => {
-    setManagedEnv({
-      PATH: '/usr/bin:/bin',
-      HOME: '/home/user',
-      SSH_AUTH_SOCK: '/tmp/ssh-agent.sock',
-      UMAMI_APP_SECRET: 'secret123',
-      UMAMI_DB_PASSWORD: 'dbpass',
-      UMAMI_ADMIN_PASSWORD: 'adminpass',
-    })
-
-    const env = getUmamiDeployEnv()
-
-    expect(env.UMAMI_APP_SECRET).toBe('secret123')
-    expect(env.UMAMI_DB_PASSWORD).toBe('dbpass')
-    expect(env.UMAMI_ADMIN_PASSWORD).toBe('adminpass')
-  })
-})
-
-// ─── validateUmamiRemotePreconditions ─────────────────────────────────────────
-
-describe('validateUmamiRemotePreconditions', () => {
-  it('throws a clear error when gh is not available', () => {
-    // We cannot reliably mock Bun.which, so we test the function contract:
-    // if gh is not installed, it should throw with a helpful message.
-    // This test verifies the error message shape by calling with a known-missing binary.
-    // In CI where gh IS installed, we skip this test.
-    if (Bun.which('gh')) {
-      // gh is available — just verify the function does not throw
-      expect(() => validateUmamiRemotePreconditions()).not.toThrow()
-      return
-    }
-
-    expect(() => validateUmamiRemotePreconditions()).toThrow('gh CLI is required')
-  })
-})
-
-// ─── deploy command (subprocess integration via CLI) ─────────────────────────
-
-describe('deploy command', () => {
-  it('dry-run remote mode prints planned gh workflow run command without executing', async () => {
-    const proc = Bun.spawn(['bun', 'run', 'packages/cli/src/cli.ts', 'umami', 'deploy', '--dry-run'], {
-      cwd: repoRoot,
-      env: {...process.env, NO_COLOR: '1'},
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-
-    const [stdout, _stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited,
-    ])
-
-    expect(exitCode).toBe(0)
-    expect(stdout).toContain('Dry run')
-    expect(stdout).toContain('Deploy Umami')
-  })
-
-  it('dry-run local mode prints planned bun command without executing', async () => {
-    const proc = Bun.spawn(['bun', 'run', 'packages/cli/src/cli.ts', 'umami', 'deploy', '--local', '--dry-run'], {
-      cwd: repoRoot,
-      env: {...process.env, NO_COLOR: '1'},
-      stdout: 'pipe',
-      stderr: 'pipe',
-    })
-
-    const [stdout, _stderr, exitCode] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
-      proc.exited,
-    ])
-
-    expect(exitCode).toBe(0)
-    expect(stdout).toContain('Dry run')
-    expect(stdout).toContain('apps/umami')
-  })
-})