@take-out/scripts 0.1.18 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "type": "module",
   "main": "./src/run.ts",
   "sideEffects": false,
@@ -29,7 +29,8 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.8.2",
-    "@take-out/helpers": "0.1.16",
+    "@lydell/node-pty": "^1.2.0-beta.3",
+    "@take-out/helpers": "0.1.20",
     "picocolors": "^1.1.1"
   },
   "peerDependencies": {

package/src/helpers/deploy-health.ts

@@ -0,0 +1,227 @@
+/**
+ * deployment health check helpers for uncloud deployments
+ * shared across repos via @take-out/scripts/helpers/deploy-health
+ */
+
+export interface SSHContext {
+  sshOpts: string
+  deployUser: string
+  deployHost: string
+  $: (
+    strings: TemplateStringsArray,
+    ...values: any[]
+  ) => { quiet: () => Promise<{ stdout: Buffer }> }
+}
+
+export interface ContainerInfo {
+  id: string
+  status: string
+  state: string
+  names: string
+  isRestarting: boolean
+}
+
+/**
+ * check for containers stuck in restart loop
+ * fails fast if any container is crash-looping
+ * excludes init containers (minio-init, migrate) that are expected to exit
+ */
+export async function checkRestartLoops(
+  ctx: SSHContext,
+  options?: { excludePatterns?: string[] }
+): Promise<{
+  hasLoop: boolean
+  services: string[]
+}> {
+  const { sshOpts, deployUser, deployHost, $ } = ctx
+  // default exclude patterns for init/oneshot containers
+  const excludePatterns = options?.excludePatterns ?? ['init', 'migrate']
+
+  try {
+    const sshCmd = `ssh ${sshOpts} ${deployUser}@${deployHost}`
+    const result =
+      await $`${sshCmd.split(' ')} "docker ps -a --format '{{.Names}} {{.Status}}'"`.quiet()
+    const lines = result.stdout.toString().trim().split('\n').filter(Boolean)
+
+    const loopingServices: string[] = []
+    for (const line of lines) {
+      if (line.includes('Restarting')) {
+        const name = line.split(' ')[0] || ''
+        // skip init/oneshot containers
+        const isExcluded = excludePatterns.some((pattern) => name.includes(pattern))
+        if (!isExcluded) {
+          loopingServices.push(name)
+        }
+      }
+    }
+
+    return { hasLoop: loopingServices.length > 0, services: loopingServices }
+  } catch {
+    return { hasLoop: false, services: [] }
+  }
+}
+
+/**
+ * get container status for all running containers
+ * extracts service name from container names (handles various naming patterns)
+ */
+export async function getContainerStatus(
+  ctx: SSHContext,
+  options?: { verbose?: boolean }
+): Promise<Map<string, ContainerInfo>> {
+  const { sshOpts, deployUser, deployHost, $ } = ctx
+  try {
+    const sshCmd = `ssh ${sshOpts} ${deployUser}@${deployHost}`
+    // use -a to see all containers including stopped/restarting
+    const result = await $`${sshCmd.split(' ')} "docker ps -a --format json"`.quiet()
+    const lines = result.stdout.toString().trim().split('\n').filter(Boolean)
+
+    const containers = new Map<string, ContainerInfo>()
+    for (const line of lines) {
+      try {
+        const container = JSON.parse(line)
+        const name = container.Names || ''
+        let serviceName: string | null = null
+
+        // try various naming patterns
+        // pattern 1: "projectname-service-1" or "projectname_service_1"
+        let match = name.match(/[^_-]+[_-]([^_-]+)[_-]\w+/)
+        if (match) {
+          serviceName = match[1]
+        } else {
+          // pattern 2: "service-xxxx" where xxxx is alphanumeric
+          match = name.match(/^([^_-]+)[_-]\w+$/)
+          if (match) {
+            serviceName = match[1]
+          } else {
+            // pattern 3: just the name before any dash or underscore
+            match = name.match(/^([^_-]+)/)
+            if (match) {
+              serviceName = match[1]
+            }
+          }
+        }
+
+        if (serviceName) {
+          const status = container.Status || ''
+          const state = container.State || ''
+          const isRestarting = state === 'restarting' || status.includes('Restarting')
+
+          containers.set(serviceName, {
+            id: container.ID,
+            status,
+            state,
+            names: container.Names,
+            isRestarting,
+          })
+        }
+      } catch {
+        // skip invalid json lines
+      }
+    }
+
+    return containers
+  } catch (error) {
+    if (options?.verbose) {
+      console.error('failed to get container status:', error)
+    }
+    return new Map()
+  }
+}
+
+/**
+ * check health status of a specific container
+ * returns 'healthy', 'checking' (mid-probe), or 'unhealthy'
+ */
+export async function checkContainerHealth(
+  ctx: SSHContext,
+  containerId: string
+): Promise<'healthy' | 'checking' | 'unhealthy'> {
+  const { sshOpts, deployUser, deployHost, $ } = ctx
+  try {
+    const sshCmd = `ssh ${sshOpts} ${deployUser}@${deployHost}`
+    const healthResult =
+      await $`${sshCmd.split(' ')} "docker inspect ${containerId} --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}no-healthcheck{{end}}'"`.quiet()
+    const healthStatus = healthResult.stdout.toString().trim()
+
+    if (healthStatus === 'healthy') {
+      return 'healthy'
+    } else if (healthStatus === 'no-healthcheck') {
+      // fall back to checking if running for containers without healthcheck
+      const statusResult =
+        await $`${sshCmd.split(' ')} "docker inspect ${containerId} --format '{{.State.Status}}'"`.quiet()
+      const status = statusResult.stdout.toString().trim()
+      return status === 'running' ? 'healthy' : 'unhealthy'
+    } else if (healthStatus === 'starting') {
+      // mid-healthcheck probe, don't treat as failure yet
+      return 'checking'
+    }
+
+    return 'unhealthy'
+  } catch {
+    return 'unhealthy'
+  }
+}
+
+/**
+ * check http health endpoint from inside web container
+ */
+export async function checkHttpHealth(
+  ctx: SSHContext,
+  options?: { endpoint?: string; containerFilter?: string }
+): Promise<{
+  healthy: boolean
+  status?: number
+  message?: string
+}> {
+  const { sshOpts, deployUser, deployHost, $ } = ctx
+  const endpoint = options?.endpoint || 'http://localhost:8081/'
+  const containerFilter = options?.containerFilter || 'web'
+
+  try {
+    const sshCmd = `ssh ${sshOpts} ${deployUser}@${deployHost}`
+    const containersResult =
+      await $`${sshCmd.split(' ')} "docker ps --filter 'name=${containerFilter}' --format '{{.Names}}'"`.quiet()
+    const webContainer = containersResult.stdout.toString().trim()
+
+    if (!webContainer) {
+      return { healthy: false, message: 'web container not found' }
+    }
+
+    const result =
+      await $`${sshCmd.split(' ')} "docker exec ${webContainer} curl -so /dev/null -w '%{http_code}' -m 5 ${endpoint}"`.quiet()
+    const output = result.stdout.toString().trim()
+    const statusCode = parseInt(output, 10)
+
+    if (statusCode >= 200 && statusCode < 400) {
+      return { healthy: true, status: statusCode }
+    } else if (statusCode >= 400 && statusCode < 500) {
+      return { healthy: true, status: statusCode, message: 'server running' }
+    } else if (statusCode >= 500) {
+      return { healthy: false, status: statusCode, message: 'server error' }
+    }
+
+    return { healthy: false, message: 'app starting...' }
+  } catch {
+    return { healthy: false, message: 'app starting...' }
+  }
+}
+
+/**
+ * get recent logs from a container
+ */
+export async function getContainerLogs(
+  ctx: SSHContext,
+  containerId: string,
+  lines = 20
+): Promise<string[]> {
+  const { sshOpts, deployUser, deployHost, $ } = ctx
+  try {
+    const sshCmd = `ssh ${sshOpts} ${deployUser}@${deployHost}`
+    const result =
+      await $`${sshCmd.split(' ')} "docker logs ${containerId} --tail ${lines} 2>&1"`.quiet()
+    return result.stdout.toString().trim().split('\n')
+  } catch {
+    return []
+  }
+}

package/src/helpers/ssh.ts

@@ -36,11 +36,15 @@ export async function testSSHConnection(
     } catch (err) {
       lastError = err as Error
       if (attempt < maxRetries) {
-        console.info(`  ssh attempt ${attempt}/${maxRetries} failed, retrying in ${retryDelay / 1000}s...`)
+        console.info(
+          `  ssh attempt ${attempt}/${maxRetries} failed, retrying in ${retryDelay / 1000}s...`
+        )
         await sleep(retryDelay)
       }
     }
   }
 
-  throw new Error(`cannot connect to ${host} after ${maxRetries} attempts - check ssh key: ${sshKey}`)
+  throw new Error(
+    `cannot connect to ${host} after ${maxRetries} attempts - check ssh key: ${sshKey}`
+  )
 }

package/src/helpers/uncloud-deploy.ts

@@ -147,10 +147,10 @@ export async function setupSSHKey(options: SetupSSHKeyOptions = {}) {
   // add host to known_hosts
   if (host) {
     try {
-      await run(
-        `ssh-keyscan -H ${host} >> ${join(sshDir, 'known_hosts')}`,
-        { silent: true, timeout: time.ms.seconds(10) }
-      )
+      await run(`ssh-keyscan -H ${host} >> ${join(sshDir, 'known_hosts')}`, {
+        silent: true,
+        timeout: time.ms.seconds(10),
+      })
     } catch {
       // ignore - ssh will prompt if needed
     }

package/src/run-pty.mjs

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs'
+import { join, relative, resolve } from 'node:path'
+
+import pty from '@lydell/node-pty'
+
+const colors = [
+  '\x1b[38;5;245m',
+  '\x1b[38;5;240m',
+  '\x1b[38;5;243m',
+  '\x1b[38;5;248m',
+  '\x1b[38;5;238m',
+  '\x1b[38;5;252m',
+]
+const reset = '\x1b[0m'
+const dim = '\x1b[2m'
+const bold = '\x1b[1m'
+const inverse = '\x1b[7m'
+
+const args = process.argv.slice(2)
+const ownFlags = ['--no-root', '--bun', '--watch', '--flags=last']
+const runCommands = []
+const forwardArgs = []
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i]
+  if (arg.startsWith('--')) {
+    if (ownFlags.includes(arg)) continue
+    forwardArgs.push(arg)
+    const nextArg = args[i + 1]
+    if (nextArg && !nextArg.startsWith('--')) {
+      forwardArgs.push(nextArg)
+      i++
+    }
+  } else {
+    runCommands.push(arg)
+  }
+}
+
+const noRoot = args.includes('--no-root')
+const runBun = args.includes('--bun')
+const flagsLast = args.includes('--flags=last')
+
+const processes = []
+let dashboardMode = false
+let selectedIndex = 0
+
+function getPrefix(index) {
+  const p = processes[index]
+  if (!p) return ''
+  const color = colors[index % colors.length]
+  return `${color}${p.shortcut} ${p.label}${reset}`
+}
+
+if (runCommands.length === 0) {
+  console.error('Usage: run-pty <script1> [script2] ...')
+  process.exit(1)
+}
+
+async function readPackageJson(dir) {
+  try {
+    return JSON.parse(await fs.promises.readFile(join(dir, 'package.json'), 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+async function getWorkspacePatterns() {
+  const pkg = await readPackageJson('.')
+  if (!pkg?.workspaces) return []
+  return Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages || []
+}
+
+async function findPackageJsonDirs(base, depth = 3) {
+  if (depth <= 0) return []
+  const results = []
+  try {
+    if (
+      await fs.promises
+        .access(join(base, 'package.json'))
+        .then(() => true)
+        .catch(() => false)
+    ) {
+      results.push(base)
+    }
+    const entries = await fs.promises.readdir(base, { withFileTypes: true })
+    for (const e of entries) {
+      if (e.isDirectory() && !e.name.startsWith('.') && e.name !== 'node_modules') {
+        results.push(...(await findPackageJsonDirs(join(base, e.name), depth - 1)))
+      }
+    }
+  } catch {}
+  return results
+}
+
+async function findWorkspaceScripts(scripts) {
+  const patterns = await getWorkspacePatterns()
+  if (!patterns.length) return new Map()
+
+  const dirs = await findPackageJsonDirs('.')
+  const result = new Map()
+
+  for (const dir of dirs) {
+    if (dir === '.') continue
+    const rel = relative('.', dir).replace(/\\/g, '/')
+    const matches = patterns.some((p) => {
+      const np = p.replace(/\\/g, '/').replace(/^\.\//, '')
+      return np.endsWith('/*')
+        ? rel.startsWith(np.slice(0, -1))
+        : rel === np || rel.startsWith(np + '/')
+    })
+    if (!matches) continue
+
+    const pkg = await readPackageJson(dir)
+    if (!pkg?.scripts) continue
+    const available = scripts.filter((s) => typeof pkg.scripts[s] === 'string')
+    if (available.length) result.set(dir, { scripts: available, name: pkg.name || dir })
+  }
+  return result
+}
+
+function spawnScript(name, cwd, label, extraArgs, index) {
+  const runArgs = ['run', '--silent', runBun ? '--bun' : '', name, ...extraArgs].filter(
+    Boolean
+  )
+
+  const terminal = pty.spawn('bun', runArgs, {
+    cwd: resolve(cwd),
+    cols: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24,
+    env: { ...process.env, FORCE_COLOR: '3' },
+  })
+
+  const idx = index ?? processes.length
+  const managed = {
+    terminal,
+    name,
+    cwd,
+    label,
+    extraArgs,
+    index: idx,
+    shortcut: '',
+    killed: false,
+  }
+
+  if (index !== undefined) {
+    processes[index] = managed
+  } else {
+    processes.push(managed)
+  }
+
+  terminal.onData((data) => {
+    if (dashboardMode) return
+    const lines = data.split('\n')
+    for (const line of lines) {
+      if (line && line !== '\r') {
+        process.stdout.write(`${getPrefix(idx)} ${line}\n`)
+      }
+    }
+  })
+
+  terminal.onExit(({ exitCode }) => {
+    if (managed.killed) return
+    if (exitCode !== 0) {
+      process.stdout.write(`${getPrefix(idx)} exited with code ${exitCode}\n`)
+    }
+  })
+
+  return managed
+}
+
+function computeShortcuts() {
+  const initials = processes.map((p) =>
+    p.label
+      .toLowerCase()
+      .split(/[^a-z]+/)
+      .filter(Boolean)
+      .map((w) => w[0])
+      .join('')
+  )
+  const lengths = new Array(processes.length).fill(1)
+
+  for (let round = 0; round < 5; round++) {
+    const shortcuts = initials.map((init, i) => init.slice(0, lengths[i]) || init)
+    const groups = new Map()
+    shortcuts.forEach((s, i) => groups.set(s, [...(groups.get(s) || []), i]))
+
+    let collision = false
+    for (const indices of groups.values()) {
+      if (indices.length > 1) {
+        collision = true
+        indices.forEach((i) => lengths[i]++)
+      }
+    }
+    if (!collision) {
+      processes.forEach((p, i) => (p.shortcut = shortcuts[i]))
+      return
+    }
+  }
+  processes.forEach(
+    (p, i) => (p.shortcut = initials[i]?.slice(0, lengths[i]) || String(i + 1))
+  )
+}
+
+function renderDashboard() {
+  process.stdout.write('\x1b[2J\x1b[H')
+  process.stdout.write(
+    `${bold}Dashboard${reset} ${dim}(↑↓ navigate, r restart, k kill, esc back)${reset}\n\n`
+  )
+
+  for (let i = 0; i < processes.length; i++) {
+    const p = processes[i]
+    const prefix = i === selectedIndex ? `${inverse} > ${reset}` : '   '
+    const status = p.killed
+      ? `${dim}(killed)${reset}`
+      : p.terminal.pid
+        ? `${dim}(pid ${p.terminal.pid})${reset}`
+        : ''
+    process.stdout.write(`${prefix} ${getPrefix(i)} ${status}\n`)
+  }
+  process.stdout.write(`\n${dim}ctrl+c to exit${reset}\n`)
+}
+
+function exitDashboard() {
+  dashboardMode = false
+  process.stdout.write('\x1b[2J\x1b[H')
+  process.stdout.write(
+    `${dim}  running ${processes.length} processes (ctrl+z dashboard, ctrl+c exit)${reset}\n\n`
+  )
+}
+
+function handleInput(data) {
+  const str = data.toString()
+
+  if (str === '\x03') {
+    cleanup()
+    return
+  }
+
+  if (str === '\x1a') {
+    if (dashboardMode) {
+      exitDashboard()
+    } else {
+      dashboardMode = true
+      renderDashboard()
+    }
+    return
+  }
+
+  if (dashboardMode) {
+    if (str === '\x1b[A') {
+      selectedIndex = Math.max(0, selectedIndex - 1)
+      renderDashboard()
+    } else if (str === '\x1b[B') {
+      selectedIndex = Math.min(processes.length - 1, selectedIndex + 1)
+      renderDashboard()
+    } else if (str === 'r' || str === 'R') {
+      const p = processes[selectedIndex]
+      if (p) {
+        p.killed = true
+        p.terminal.kill()
+        setTimeout(() => {
+          spawnScript(p.name, p.cwd, p.label, p.extraArgs, p.index)
+          exitDashboard()
+        }, 100)
+      }
+    } else if (str === 'k' || str === 'K') {
+      const p = processes[selectedIndex]
+      if (p && !p.killed) {
+        p.killed = true
+        p.terminal.kill()
+        renderDashboard()
+      }
+    } else if (str === '\x1b' || str === '\x1b\x1b') {
+      exitDashboard()
+    }
+  }
+}
+
+function cleanup() {
+  process.stdout.write('\n')
+  for (const p of processes) {
+    if (!p.killed) {
+      p.killed = true
+      p.terminal.kill()
+    }
+  }
+  process.exit(0)
+}
+
+async function main() {
+  const lastScript = runCommands[runCommands.length - 1]
+
+  if (!noRoot) {
+    const pkg = await readPackageJson('.')
+    if (pkg?.scripts) {
+      for (const name of runCommands) {
+        if (typeof pkg.scripts[name] === 'string') {
+          const scriptArgs = !flagsLast || name === lastScript ? forwardArgs : []
+          spawnScript(name, '.', name, scriptArgs)
+        }
+      }
+    }
+  }
+
+  const wsScripts = await findWorkspaceScripts(runCommands)
+  for (const [dir, { scripts, name }] of wsScripts) {
+    for (const script of scripts) {
+      const scriptArgs = !flagsLast || script === lastScript ? forwardArgs : []
+      spawnScript(script, dir, `${name} ${script}`, scriptArgs)
+    }
+  }
+
+  if (processes.length === 0) {
+    console.error('No scripts found')
+    process.exit(1)
+  }
+
+  computeShortcuts()
+  process.stdout.write(
+    `${dim}  running ${processes.length} processes (ctrl+z dashboard, ctrl+c exit)${reset}\n\n`
+  )
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true)
+    process.stdin.resume()
+    process.stdin.on('data', handleInput)
+  }
+
+  process.stdout.on('resize', () => {
+    const cols = process.stdout.columns || 80
+    const rows = process.stdout.rows || 24
+    for (const p of processes) {
+      if (!p.killed) {
+        p.terminal.resize(cols, rows)
+      }
+    }
+  })
+
+  process.on('SIGINT', cleanup)
+  process.on('SIGTERM', cleanup)
+}
+
+main().catch((e) => {
+  console.error(e)
+  process.exit(1)
+})