@marcusrbrown/infra 0.13.1 → 0.13.2

package/src/commands/gateway/status.ts

@@ -1,255 +0,0 @@
-import type {goke} from 'goke'
-import type {ActionCtx} from '../../lib/action-ctx'
-import type {StatusSummary} from '../status'
-import {z} from 'zod'
-
-import {buildKnownHostsArgs} from '../../lib/known-hosts'
-import {redactHost} from '../../lib/redact'
-import {buildIdentityArgs} from '../../lib/ssh-identity'
-// ─── Minimal ctx interface (subset of GokeExecutionContext used by this action) ─
-import {validateGatewayHost} from './host'
-
-declare const process: {
-  env: Record<string, string | undefined>
-  exitCode?: number
-}
-
-const COMPOSE_PROJECT_DIR = '/opt/gateway/deploy'
-
-// ─── Types ───────────────────────────────────────────────────────────────────
-
-export interface ComposePsEntry {
-  Name: string
-  State: string
-  Health: string
-}
-
-export type HealthStatus = 'healthy' | 'unhealthy' | 'starting' | 'n-a'
-
-export interface ServiceRow {
-  service: string
-  state: string
-  health: HealthStatus
-}
-
-export interface GatewayStatusResult {
-  ok: boolean
-  services: ServiceRow[]
-  error?: string
-}
-
-export type SpawnFn = (
-  cmd: string[],
-  opts: {env: Record<string, string>; stdout: 'pipe'; stderr: 'pipe'},
-) => {
-  stdout: ReadableStream<Uint8Array>
-  stderr: ReadableStream<Uint8Array>
-  exited: Promise<number>
-}
-
-// ─── Pure helpers ─────────────────────────────────────────────────────────────
-
-export function parseComposePsOutput(stdoutText: string): ComposePsEntry[] {
-  const trimmed = stdoutText.trim()
-  if (trimmed.length === 0) return []
-
-  // Legacy compose may emit a single JSON array; current versions emit NDJSON.
-  if (trimmed.startsWith('[')) {
-    const parsed: unknown = JSON.parse(trimmed)
-    return Array.isArray(parsed) ? (parsed as ComposePsEntry[]) : []
-  }
-
-  // NDJSON: one JSON object per non-empty line.
-  return trimmed
-    .split('\n')
-    .map(line => line.trim())
-    .filter(line => line.length > 0)
-    .map(line => JSON.parse(line) as ComposePsEntry)
-}
-
-function normalizeHealth(raw: string): HealthStatus {
-  if (raw === 'healthy' || raw === 'unhealthy' || raw === 'starting') {
-    return raw
-  }
-
-  return 'n-a'
-}
-
-export function parseComposePs(entries: ComposePsEntry[]): ServiceRow[] {
-  return entries.map(entry => ({
-    service: entry.Name,
-    state: entry.State,
-    // Workspace has no upstream healthcheck in v1; health will upgrade automatically
-    // when upstream adds one and docker compose ps starts reporting it.
-    health: normalizeHealth(entry.Health),
-  }))
-}
-
-export function isAllRunning(rows: ServiceRow[]): boolean {
-  return rows.every(row => row.state === 'running')
-}
-
-// ─── SSH-backed status fetch ──────────────────────────────────────────────────
-
-function defaultSpawn(
-  cmd: string[],
-  opts: {env: Record<string, string>; stdout: 'pipe'; stderr: 'pipe'},
-): ReturnType<SpawnFn> {
-  return Bun.spawn(cmd, opts) as ReturnType<SpawnFn>
-}
-
-export async function getGatewayComposeStatus(
-  host: string,
-  spawn: SpawnFn = defaultSpawn,
-): Promise<GatewayStatusResult> {
-  validateGatewayHost(host)
-
-  const knownHostsArgs = buildKnownHostsArgs()
-  const {args: identityArgs, cleanup} = buildIdentityArgs(process.env.GATEWAY_SSH_KEY)
-
-  const sshCmd = [
-    'ssh',
-    '-o',
-    'BatchMode=yes',
-    '-o',
-    'StrictHostKeyChecking=yes',
-    ...knownHostsArgs,
-    ...identityArgs,
-    `root@${host}`,
-    `docker compose --project-directory ${COMPOSE_PROJECT_DIR} ps --format json`,
-  ]
-
-  const env: Record<string, string> = {
-    PATH: process.env.PATH ?? '/usr/bin:/bin',
-    HOME: process.env.HOME ?? '/tmp',
-    ...(process.env.SSH_AUTH_SOCK ? {SSH_AUTH_SOCK: process.env.SSH_AUTH_SOCK} : {}),
-  }
-
-  let stdoutText: string
-  let stderrText: string
-  let exitCode: number
-
-  try {
-    const child = spawn(sshCmd, {env, stdout: 'pipe', stderr: 'pipe'})
-    ;[stdoutText, stderrText, exitCode] = await Promise.all([
-      new Response(child.stdout).text(),
-      new Response(child.stderr).text(),
-      child.exited,
-    ])
-  } finally {
-    cleanup()
-  }
-
-  if (exitCode !== 0) {
-    const redacted = redactHost(stderrText.trim(), host) || 'unknown error'
-    return {
-      ok: false,
-      services: [],
-      error: `SSH command failed (exit ${exitCode}): ${redacted}`,
-    }
-  }
-
-  let entries: ComposePsEntry[]
-
-  try {
-    entries = parseComposePsOutput(stdoutText)
-  } catch {
-    return {
-      ok: false,
-      services: [],
-      error: `Failed to parse docker compose ps output: ${redactHost(stdoutText.slice(0, 200), host)}`,
-    }
-  }
-
-  const services = parseComposePs(entries)
-  const ok = isAllRunning(services)
-
-  return {ok, services}
-}
-
-// ─── Unified status aggregator export ────────────────────────────────────────
-
-export async function getGatewayStatusSummary(host: string): Promise<StatusSummary> {
-  const result = await getGatewayComposeStatus(host)
-
-  if (!result.ok || result.services.length === 0) {
-    const errorMsg = result.error ?? 'No services reported'
-    return {
-      app: 'gateway',
-      http: `ERROR: ${errorMsg}`,
-      lastDeploy: '—',
-      version: '—',
-      contentHash: '—',
-      usageStats: '—',
-    }
-  }
-
-  const rows = result.services.map(s => `${s.service}:${s.state}/${s.health}`).join(', ')
-
-  return {
-    app: 'gateway',
-    http: `OK: ${rows}`,
-    lastDeploy: '—',
-    version: '—',
-    contentHash: '—',
-    usageStats: '—',
-  }
-}
-
-// ─── Action (exported for direct testing) ────────────────────────────────────
-
-export async function gatewayStatusAction(
-  options: {key?: string | undefined},
-  ctx: ActionCtx,
-  spawn?: SpawnFn,
-): Promise<void> {
-  const hostEnvKey = options.key ?? 'GATEWAY_HOST'
-  const host = process.env[hostEnvKey]
-
-  if (!host) {
-    ctx.console.error(`Gateway host not set. Export ${hostEnvKey} or pass --key <env-name> pointing to a set variable.`)
-    ctx.process.exit(1)
-    return
-  }
-
-  ctx.console.log('Gateway status')
-  ctx.console.log('')
-
-  const result = await getGatewayComposeStatus(host, spawn)
-
-  if (!result.ok && result.services.length === 0) {
-    ctx.console.error(`Error: ${result.error ?? 'Unknown error'}`)
-    ctx.process.exit(1)
-    return
-  }
-
-  ctx.console.log('Service          State      Health')
-  ctx.console.log('─────────────────────────────────────')
-
-  for (const row of result.services) {
-    const svc = row.service.padEnd(16)
-    const state = row.state.padEnd(10)
-    ctx.console.log(`${svc} ${state} ${row.health}`)
-  }
-
-  ctx.console.log('')
-
-  if (result.ok) {
-    ctx.console.log('Status: OK')
-  } else {
-    ctx.console.log('Status: DEGRADED (one or more services not running)')
-    ctx.process.exit(1)
-  }
-}
-
-// ─── Command registration ─────────────────────────────────────────────────────
-
-export function registerGatewayStatus(cli: ReturnType<typeof goke>): void {
-  cli
-    .command('gateway status', 'Show operational health of the gateway deployment via docker compose ps.')
-    .option(
-      '--key [key]',
-      z.string().describe('Environment variable name holding the SSH host. Falls back to GATEWAY_HOST when omitted.'),
-    )
-    .action((options, ctx) => gatewayStatusAction(options, ctx))
-}

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

@@ -1,177 +0,0 @@
-import {resolve} from 'node:path'
-import {afterEach, beforeEach, describe, expect, it, spyOn} from 'bun:test'
-
-import {getLocalDeployEnv, resolveDeployScriptPath, resolveDistIndexPath, validateRemotePreconditions} from './deploy'
-
-const cliDir = resolve(import.meta.dir, '../../..')
-
-const envKeys = ['HOST', 'HOME', 'PATH', 'REMOTE_USER', 'SITE_DIR', '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] = 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', 'keeweb', 'deploy', ...args], {
-    cwd: cliDir,
-    env: {
-      ...env,
-      NO_COLOR: '1',
-      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('keeweb deploy', () => {
-  beforeEach(() => {
-    originalEnv = Object.fromEntries(envKeys.map(key => [key, process.env[key]]))
-  })
-
-  afterEach(() => {
-    restoreManagedEnv()
-  })
-
-  describe('resolveDeployScriptPath', () => {
-    it('returns a string path containing deploy.sh', () => {
-      const deployScriptPath = resolveDeployScriptPath()
-
-      expect(typeof deployScriptPath).toBe('string')
-      expect(deployScriptPath).toContain('deploy.sh')
-    })
-  })
-
-  describe('resolveDistIndexPath', () => {
-    it('returns a string path ending with dist/index.html', () => {
-      const distIndexPath = resolveDistIndexPath()
-
-      expect(typeof distIndexPath).toBe('string')
-      expect(distIndexPath).toEndWith('dist/index.html')
-    })
-  })
-
-  describe('getLocalDeployEnv', () => {
-    it('returns the expected deploy environment when required variables are present', () => {
-      setManagedEnv({
-        HOME: '/tmp/test-home',
-        PATH: '/usr/bin:/bin',
-        SSH_AUTH_SOCK: '/tmp/test-sock',
-      })
-
-      expect(getLocalDeployEnv()).toEqual({
-        HOME: '/tmp/test-home',
-        HOST: 'box.heatvision.co',
-        PATH: '/usr/bin:/bin',
-        REMOTE_USER: 'deploy-kw',
-        SITE_DIR: '/home/user-data/www/kw.igg.ms',
-        SSH_AUTH_SOCK: '/tmp/test-sock',
-      })
-    })
-
-    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/)
-    })
-
-    it('throws when PATH is missing', () => {
-      setManagedEnv({
-        HOME: '/tmp/test-home',
-        PATH: undefined,
-        SSH_AUTH_SOCK: '/tmp/test-sock',
-      })
-
-      expect(() => getLocalDeployEnv()).toThrow(/PATH/)
-    })
-  })
-
-  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('rejects --nginx without --local', async () => {
-      const {stdout, stderr, exitCode} = await runDeployCommand(['--nginx'])
-
-      expect(exitCode).not.toBe(0)
-      expect(`${stdout}${stderr}`).toContain('only valid with --local')
-    })
-
-    it('prints the local dry-run plan without executing deploy.sh', async () => {
-      const deployScriptPath = resolveDeployScriptPath()
-      const {stdout, stderr, exitCode} = await runDeployCommand(['--local', '--dry-run'])
-
-      expect(exitCode).toBe(0)
-      expect(stderr).toBe('')
-      expect(stdout).toContain('Dry run: local KeeWeb deploy')
-      expect(stdout).toContain(deployScriptPath)
-    })
-  })
-})

package/src/commands/keeweb/deploy.ts

@@ -1,191 +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 KeeWeb'
-const WORKFLOW_URL = 'https://github.com/marcusrbrown/infra/actions/workflows/deploy-keeweb.yaml'
-
-const DEFAULT_HOST = 'box.heatvision.co'
-const DEFAULT_REMOTE_USER = 'deploy-kw'
-const DEFAULT_SITE_DIR = '/home/user-data/www/kw.igg.ms'
-
-type CliInstance = ReturnType<typeof goke>
-
-export function resolveDeployScriptPath(): string {
-  const primary = resolve(import.meta.dir, '../../../../../apps/keeweb/deploy.sh')
-
-  if (existsSync(primary)) {
-    return primary
-  }
-
-  return resolve(import.meta.dir, '../../../../apps/keeweb/deploy.sh')
-}
-
-export function resolveDistIndexPath(): string {
-  return resolve(import.meta.dir, '../../../../../apps/keeweb/dist/index.html')
-}
-
-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 {
-    HOST: process.env.HOST ?? DEFAULT_HOST,
-    REMOTE_USER: process.env.REMOTE_USER ?? DEFAULT_REMOTE_USER,
-    SITE_DIR: process.env.SITE_DIR ?? DEFAULT_SITE_DIR,
-    SSH_AUTH_SOCK: sshAuthSock,
-    PATH: path,
-    HOME: home,
-  }
-}
-
-export function validateLocalPreconditions(options: {nginx?: boolean}): {
-  deployScriptPath: string
-  distIndexPath: string
-} {
-  const deployScriptPath = resolveDeployScriptPath()
-  if (!existsSync(deployScriptPath)) {
-    throw new Error(`deploy.sh not found at expected path: ${deployScriptPath}`)
-  }
-
-  const distIndexPath = resolveDistIndexPath()
-  if (!existsSync(distIndexPath)) {
-    throw new Error(`Local deploy requires built assets. Missing: ${distIndexPath}`)
-  }
-
-  getLocalDeployEnv()
-
-  if (options.nginx) {
-    // no-op placeholder to keep validation branch explicit
-  }
-
-  return {deployScriptPath, distIndexPath}
-}
-
-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 registerKeewebDeploy(cli: CliInstance): void {
-  cli
-    .command(
-      'keeweb deploy',
-      'Trigger KeeWeb deployment. Default mode dispatches the GitHub Deploy KeeWeb workflow. Use --local to run apps/keeweb/deploy.sh directly from this repo.',
-    )
-    .option(
-      '--local',
-      z
-        .boolean()
-        .default(false)
-        .describe('Run local deployment using apps/keeweb/deploy.sh instead of triggering GitHub Actions.'),
-    )
-    .option(
-      '--nginx',
-      z
-        .boolean()
-        .default(false)
-        .describe(
-          'Include nginx config deployment. Valid only with --local and passed through to deploy.sh as --nginx.',
-        ),
-    )
-    .option(
-      '--dry-run',
-      z
-        .boolean()
-        .default(false)
-        .describe(
-          'Print planned actions without validating preconditions, executing deploy.sh, or triggering GitHub Actions.',
-        ),
-    )
-    .example('# Trigger GitHub Deploy KeeWeb workflow (default mode)')
-    .example('infra keeweb deploy')
-    .example('# Preview local deploy plan without side effects')
-    .example('infra keeweb deploy --local --dry-run')
-    .example('# Run local deploy including nginx config update')
-    .example('infra keeweb deploy --local --nginx')
-    .action(async options => {
-      if (options.nginx && !options.local) {
-        throw new Error('--nginx is only valid with --local')
-      }
-
-      if (options.local) {
-        if (options.dryRun) {
-          const deployScriptPath = resolveDeployScriptPath()
-          const args = ['bash', deployScriptPath]
-          if (options.nginx) {
-            args.push('--nginx')
-          }
-          console.log('Dry run: local KeeWeb deploy')
-          console.log(`- deploy script: ${deployScriptPath}`)
-          console.log(`- dist check: ${resolveDistIndexPath()}`)
-          console.log(`- command: ${args.join(' ')}`)
-          return
-        }
-
-        const {deployScriptPath} = validateLocalPreconditions({nginx: options.nginx})
-        const env = getLocalDeployEnv()
-        const args = ['bash', deployScriptPath]
-
-        if (options.nginx) {
-          args.push('--nginx')
-        }
-
-        const child = Bun.spawn(args, {
-          env,
-          stdout: 'inherit',
-          stderr: 'inherit',
-        })
-
-        const exitCode = await child.exited
-        if (exitCode !== 0) {
-          throw new Error(`Local deploy failed with exit code ${exitCode}`)
-        }
-
-        return
-      }
-
-      if (options.dryRun) {
-        console.log('Dry run: remote KeeWeb deploy')
-        console.log(`- command: gh workflow run ${WORKFLOW_NAME} --repo ${REPO}`)
-        console.log(`- workflow URL: ${WORKFLOW_URL}`)
-        return
-      }
-
-      validateRemotePreconditions()
-
-      console.warn(
-        'Warning: the Deploy KeeWeb workflow includes nginx config deployment as part of workflow_dispatch logic.',
-      )
-      console.warn('Warning: the workflow requires keeweb environment approval before jobs execute.')
-
-      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 Deploy KeeWeb workflow (exit code ${exitCode})`)
-      }
-
-      console.log(`Workflow triggered: ${WORKFLOW_URL}`)
-      console.log('Approve the keeweb environment deployment in GitHub Actions to continue.')
-    })
-}

package/src/commands/keeweb/index.ts

@@ -1,11 +0,0 @@
-import type {goke} from 'goke'
-
-import {registerKeewebDeploy} from './deploy'
-import {registerKeewebOpen} from './open'
-import {registerKeewebStatus} from './status'
-
-export function registerKeewebCommands(cli: ReturnType<typeof goke>): void {
-  registerKeewebStatus(cli)
-  registerKeewebDeploy(cli)
-  registerKeewebOpen(cli)
-}

package/src/commands/keeweb/open.test.ts

@@ -1,54 +0,0 @@
-import {resolve} from 'node:path'
-import {describe, expect, it} from 'bun:test'
-
-import {getOpenerCommand, KEEWEB_URL} from './open'
-
-const cliDir = resolve(import.meta.dir, '../../..')
-
-describe('keeweb open', () => {
-  describe('getOpenerCommand', () => {
-    it('returns "open" on darwin', () => {
-      const originalPlatform = process.platform
-      Object.defineProperty(process, 'platform', {value: 'darwin', configurable: true})
-
-      expect(getOpenerCommand()).toBe('open')
-
-      Object.defineProperty(process, 'platform', {value: originalPlatform, configurable: true})
-    })
-
-    it('returns "xdg-open" on linux', () => {
-      const originalPlatform = process.platform
-      Object.defineProperty(process, 'platform', {value: 'linux', configurable: true})
-
-      expect(getOpenerCommand()).toBe('xdg-open')
-
-      Object.defineProperty(process, 'platform', {value: originalPlatform, configurable: true})
-    })
-  })
-
-  describe('KEEWEB_URL', () => {
-    it('is the expected URL', () => {
-      expect(KEEWEB_URL).toBe('https://kw.igg.ms/')
-    })
-  })
-
-  describe('CLI help', () => {
-    it('prints help text', async () => {
-      const proc = Bun.spawn(['bun', 'src/cli.ts', 'keeweb', 'open', '--help'], {
-        cwd: cliDir,
-        env: {...process.env, NO_COLOR: '1'},
-        stdout: 'pipe',
-        stderr: 'pipe',
-      })
-
-      const [stdout, , exitCode] = await Promise.all([
-        new Response(proc.stdout).text(),
-        new Response(proc.stderr).text(),
-        proc.exited,
-      ])
-
-      expect(exitCode).toBe(0)
-      expect(stdout).toContain('Open KeeWeb in the default browser')
-    })
-  })
-})