@o/scripts 0.16.19-canary.1790165522484

package/src/helpers/github-tail.ts

@@ -0,0 +1,249 @@
+/**
+ * tail github actions ci logs for the latest run
+ */
+
+import { execSync, spawn } from 'node:child_process'
+
+export interface GithubTailOptions {
+  /** workflow name to look for (default: 'CI') */
+  workflowName?: string
+  /** job name to tail (default: 'build-test-and-deploy') */
+  jobName?: string
+  /** only show failed step logs */
+  showOnlyFailed?: boolean
+  /** force watch mode even for completed jobs */
+  forceWatch?: boolean
+}
+
+function getFailedStepLogs(jobId: string, stepName: string): string {
+  try {
+    const logs = execSync(
+      `gh run view --job ${jobId} --log 2>/dev/null | grep -A 100 -B 20 "${stepName}"`,
+      {
+        encoding: 'utf-8',
+        shell: '/bin/bash',
+        maxBuffer: 10 * 1024 * 1024,
+      }
+    )
+    return logs
+  } catch {
+    try {
+      const logs = execSync(`gh run view --job ${jobId} --log-failed 2>/dev/null`, {
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024,
+      })
+      return logs
+    } catch {
+      return ''
+    }
+  }
+}
+
+async function watchJob(
+  runId: string,
+  jobId: string,
+  jobName: string,
+  showOnlyFailed: boolean
+) {
+  try {
+    const jobsJson = execSync(`gh run view ${runId} --json jobs`, {
+      encoding: 'utf-8',
+    })
+    const { jobs } = JSON.parse(jobsJson)
+    const job = jobs.find((j: any) => j.name === jobName)
+
+    if (job && job.status === 'completed') {
+      console.info(`\nJob already completed with conclusion: ${job.conclusion}\n`)
+
+      if (job.conclusion === 'failure') {
+        const failedSteps =
+          job.steps?.filter((s: any) => s.conclusion === 'failure') || []
+        if (failedSteps.length > 0) {
+          console.info(`❌ Failed step: ${failedSteps[0].name}\n`)
+          console.info('🔍 Showing failure details...\n')
+          console.info('─'.repeat(80))
+
+          const failureLogs = getFailedStepLogs(jobId, failedSteps[0].name)
+          if (failureLogs) {
+            console.info(failureLogs)
+          } else {
+            execSync(`gh run view --job ${jobId} --log-failed`, {
+              stdio: 'inherit',
+            })
+          }
+        } else {
+          execSync(`gh run view --job ${jobId} --log-failed`, {
+            stdio: 'inherit',
+          })
+        }
+      } else {
+        if (!showOnlyFailed) {
+          execSync(`gh run view --job ${jobId} --log`, {
+            stdio: 'inherit',
+          })
+        }
+      }
+
+      process.exit(job.conclusion === 'success' ? 0 : 1)
+    }
+  } catch {
+    // continue to watch mode
+  }
+
+  console.info('\n📡 Watching CI logs...\n')
+  console.info('─'.repeat(80))
+
+  const watchProcess = spawn('gh', ['run', 'watch', runId, '--exit-status'], {
+    stdio: 'inherit',
+  })
+
+  watchProcess.on('exit', async (code) => {
+    if (code !== 0) {
+      console.info('\n❌ CI failed! Getting detailed logs...\n')
+      console.info('─'.repeat(80))
+
+      try {
+        const jobsJson = execSync(`gh run view ${runId} --json jobs`, {
+          encoding: 'utf-8',
+        })
+        const { jobs } = JSON.parse(jobsJson)
+        const job = jobs.find((j: any) => j.name === jobName)
+
+        if (job) {
+          const failedSteps =
+            job.steps?.filter((s: any) => s.conclusion === 'failure') || []
+          if (failedSteps.length > 0) {
+            console.info(
+              `Failed steps: ${failedSteps.map((s: any) => s.name).join(', ')}\n`
+            )
+
+            for (const step of failedSteps) {
+              console.info(`\n━━━ Logs for failed step: ${step.name} ━━━\n`)
+              const stepLogs = getFailedStepLogs(jobId, step.name)
+              if (stepLogs) {
+                console.info(stepLogs)
+              }
+            }
+          }
+        }
+
+        console.info('\n━━━ Summary of all failed steps ━━━\n')
+        execSync(`gh run view --job ${jobId} --log-failed`, {
+          stdio: 'inherit',
+        })
+      } catch {
+        console.error('Could not retrieve detailed failure logs')
+      }
+    }
+
+    process.exit(code || 0)
+  })
+
+  process.on('SIGINT', () => {
+    watchProcess.kill()
+    process.exit(0)
+  })
+}
+
+export async function githubTail(options: GithubTailOptions = {}) {
+  const {
+    workflowName = 'CI',
+    jobName = 'build-test-and-deploy',
+    showOnlyFailed = false,
+    forceWatch = false,
+  } = options
+
+  try {
+    let latestCommit = execSync('git rev-parse HEAD', { encoding: 'utf-8' }).trim()
+    let shortCommit = latestCommit.substring(0, 7)
+
+    console.info(`Fetching CI logs for commit: ${shortCommit}`)
+
+    let runsJson = execSync(
+      `gh run list --commit ${latestCommit} --json databaseId,name,status,conclusion --limit 5`,
+      { encoding: 'utf-8' }
+    )
+    let runs = JSON.parse(runsJson)
+    let ciRun = runs.find((r: any) => r.name === workflowName)
+
+    if (!ciRun) {
+      console.info('No CI run found for local commit, checking remote...')
+
+      latestCommit = execSync('git rev-parse origin/main', { encoding: 'utf-8' }).trim()
+      shortCommit = latestCommit.substring(0, 7)
+
+      console.info(`Fetching CI logs for remote commit: ${shortCommit}`)
+
+      runsJson = execSync(
+        `gh run list --commit ${latestCommit} --json databaseId,name,status,conclusion --limit 5`,
+        { encoding: 'utf-8' }
+      )
+      runs = JSON.parse(runsJson)
+      ciRun = runs.find((r: any) => r.name === workflowName)
+
+      if (!ciRun) {
+        console.info('No CI run for remote HEAD, getting latest CI run...')
+        runsJson = execSync(
+          `gh run list --workflow=${workflowName} --json databaseId,name,status,conclusion,headSha --limit 1`,
+          { encoding: 'utf-8' }
+        )
+        runs = JSON.parse(runsJson)
+        ciRun = runs[0]
+
+        if (ciRun) {
+          shortCommit = ciRun.headSha?.substring(0, 7) || 'unknown'
+          console.info(`Using latest CI run for commit: ${shortCommit}`)
+        }
+      }
+    }
+
+    if (!ciRun) {
+      console.error('No CI runs found')
+      process.exit(1)
+    }
+
+    console.info(`CI Run: ${ciRun.status} (${ciRun.conclusion || 'in progress'})`)
+
+    const jobsJson = execSync(`gh run view ${ciRun.databaseId} --json jobs`, {
+      encoding: 'utf-8',
+    })
+    const { jobs } = JSON.parse(jobsJson)
+    const buildJob = jobs.find((j: any) => j.name === jobName)
+
+    if (!buildJob) {
+      console.error(`No ${jobName} job found`)
+      process.exit(1)
+    }
+
+    console.info(
+      `\nJob: ${buildJob.name} - ${buildJob.status} (${buildJob.conclusion || 'in progress'})`
+    )
+    console.info('─'.repeat(80))
+
+    if (buildJob.status === 'completed' && !forceWatch) {
+      const logFlag =
+        showOnlyFailed || buildJob.conclusion === 'failure' ? '--log-failed' : '--log'
+
+      if (buildJob.conclusion === 'failure') {
+        console.info('\n❌ Job failed! Showing failed steps...\n')
+      } else if (showOnlyFailed) {
+        console.info('\n🔍 Showing only failed steps...\n')
+      }
+
+      execSync(`gh run view --job ${buildJob.databaseId} ${logFlag}`, {
+        stdio: 'inherit',
+      })
+
+      process.exit(buildJob.conclusion === 'success' ? 0 : 1)
+    } else {
+      await watchJob(ciRun.databaseId, buildJob.databaseId, jobName, showOnlyFailed)
+    }
+  } catch (error: any) {
+    if (error.status === 1 && error.stdout?.includes('No jobs in progress')) {
+      console.info('Job completed. Run again to see full logs.')
+    } else {
+      console.error('Error fetching CI logs:', error.message)
+      process.exit(1)
+    }
+  }
+}

package/src/helpers/multipass.ts

@@ -0,0 +1,174 @@
+import fs from 'node:fs'
+
+import { sleep } from '@o/helpers'
+
+import { run } from './run'
+
+export interface MultipassConfig {
+  vmName: string
+  sshKeyPath: string
+}
+
+export function createMultipassConfig(
+  name: string,
+  sshKeyPath?: string
+): MultipassConfig {
+  return {
+    vmName: name,
+    sshKeyPath: sshKeyPath || `${process.env.HOME}/.ssh/${name}`,
+  }
+}
+
+export async function checkMultipass(): Promise<void> {
+  try {
+    await run('multipass --version', { silent: true })
+    console.info('✅ multipass installed')
+  } catch {
+    throw new Error('multipass not found - install: brew install multipass')
+  }
+}
+
+export async function getVMIP(config: MultipassConfig): Promise<string | null> {
+  try {
+    const { stdout } = await run(`multipass info ${config.vmName} --format json`, {
+      silent: true,
+      captureOutput: true,
+    })
+    const data = JSON.parse(stdout)
+    return data.info[config.vmName]?.ipv4?.[0] || null
+  } catch {
+    return null
+  }
+}
+
+export async function vmExists(config: MultipassConfig): Promise<boolean> {
+  try {
+    const { stdout } = await run('multipass list', { silent: true, captureOutput: true })
+    return stdout.includes(config.vmName)
+  } catch {
+    return false
+  }
+}
+
+export async function createVM(config: MultipassConfig): Promise<void> {
+  console.info('\n🖥️  creating multipass vm...\n')
+
+  if (await vmExists(config)) {
+    console.info(`✅ vm '${config.vmName}' already exists`)
+    return
+  }
+
+  const cloudInit = `#cloud-config
+package_update: true
+package_upgrade: true
+packages:
+  - curl
+`
+
+  const cloudInitPath = `${process.cwd()}/.cloud-init.yml`
+  fs.writeFileSync(cloudInitPath, cloudInit)
+
+  try {
+    await run(
+      `multipass launch --name ${config.vmName} --cpus 4 --memory 4G --disk 20G --cloud-init ${cloudInitPath}`
+    )
+  } finally {
+    await run(`rm -f ${cloudInitPath}`, { silent: true })
+  }
+
+  console.info('\n⏳ waiting for vm to be ready...')
+
+  let attempts = 0
+  while (attempts < 30) {
+    try {
+      const { stdout } = await run(`multipass info ${config.vmName} --format json`, {
+        silent: true,
+        captureOutput: true,
+      })
+      const data = JSON.parse(stdout)
+      if (data.info[config.vmName]?.state === 'Running') {
+        break
+      }
+    } catch {
+      // vm not ready yet
+    }
+    await sleep(2000)
+    attempts++
+  }
+
+  // wait for cloud-init
+  console.info('waiting for cloud-init to complete...')
+  await sleep(10000)
+
+  try {
+    await run(`multipass exec ${config.vmName} -- timeout 300 cloud-init status --wait`)
+    console.info('✅ cloud-init complete')
+  } catch {
+    console.info('⚠️  cloud-init status check timed out, continuing...')
+  }
+
+  console.info('✅ vm ready')
+}
+
+export async function setupVMSSH(config: MultipassConfig): Promise<void> {
+  console.info('\n🔑 setting up ssh...\n')
+
+  try {
+    await run(`test -f ${config.sshKeyPath}`, { silent: true })
+    console.info('✅ ssh key exists')
+  } catch {
+    console.info('generating ssh key...')
+    await run(`ssh-keygen -t rsa -b 4096 -f ${config.sshKeyPath} -N ""`, { silent: true })
+    console.info('✅ ssh key generated')
+  }
+
+  const { stdout: pubKey } = await run(`cat ${config.sshKeyPath}.pub`, {
+    silent: true,
+    captureOutput: true,
+  })
+  await run(
+    `multipass exec ${config.vmName} -- sh -c 'mkdir -p ~/.ssh && echo "${pubKey.trim()}" >> ~/.ssh/authorized_keys'`
+  )
+  console.info('✅ ssh key configured')
+}
+
+export async function setupPortForward(
+  config: MultipassConfig,
+  ports: { local: number; containerName: string; containerPort: number }[]
+): Promise<void> {
+  console.info('\n🌐 setting up port forwarding...\n')
+
+  const ip = await getVMIP(config)
+  if (!ip) {
+    console.error('❌ could not get vm ip')
+    return
+  }
+
+  const forwards: string[] = []
+  for (const { local, containerName, containerPort } of ports) {
+    const { stdout: containerIP } = await run(
+      `multipass exec ${config.vmName} -- sudo docker inspect $(multipass exec ${config.vmName} -- sudo docker ps -q -f name=${containerName}) -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}'`,
+      { silent: true, captureOutput: true }
+    )
+    console.info(`${containerName} container: ${containerIP.trim()}:${containerPort}`)
+    forwards.push(`-L ${local}:${containerIP.trim()}:${containerPort}`)
+  }
+
+  // kill any existing port forwards
+  try {
+    await run(`pkill -f "ssh.*${config.vmName}"`, { silent: true })
+  } catch {
+    // ignore if none found
+  }
+
+  for (const { local, containerName, containerPort } of ports) {
+    console.info(`forwarding localhost:${local} -> ${containerName}:${containerPort}`)
+  }
+
+  await run(
+    `ssh -i ${config.sshKeyPath} -o StrictHostKeyChecking=no -f -N ${forwards.join(' ')} ubuntu@${ip}`,
+    { silent: true }
+  )
+
+  console.info('✅ port forwarding active')
+}

package/src/helpers/parse-env-file.ts

@@ -0,0 +1,71 @@
+/**
+ * parse a .env file, handling multi-line quoted values (PEM keys etc)
+ */
+export function parseEnvFile(
+  content: string,
+  options?: { allowedKeys?: string[] }
+): Record<string, string> {
+  const result: Record<string, string> = {}
+  const lines = content.split('\n')
+  let currentKey: string | null = null
+  let currentValue: string[] = []
+  let inMultiline = false
+
+  const save = () => {
+    if (!currentKey) return
+    if (options?.allowedKeys && !options.allowedKeys.includes(currentKey)) {
+      currentKey = null
+      currentValue = []
+      inMultiline = false
+      return
+    }
+    let value = currentValue.join('\n')
+    // remove surrounding quotes
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1)
+    }
+    value = value.replace(/\\"/g, '"')
+    result[currentKey] = value
+    currentKey = null
+    currentValue = []
+    inMultiline = false
+  }
+
+  for (const line of lines) {
+    if (inMultiline) {
+      currentValue.push(line)
+      if (line.trim().endsWith('"') || line.trim().endsWith("'")) {
+        save()
+      }
+      continue
+    }
+
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#')) continue
+
+    const match = trimmed.match(/^([A-Z_][A-Z0-9_]*)=(.*)$/)
+    if (match && match[1]) {
+      if (currentKey) save()
+
+      currentKey = match[1]
+      const valueStart = match[2] || ''
+
+      if (
+        (valueStart.startsWith('"') && !valueStart.endsWith('"')) ||
+        (valueStart.startsWith("'") && !valueStart.endsWith("'"))
+      ) {
+        inMultiline = true
+        currentValue = [valueStart]
+      } else {
+        currentValue = [valueStart]
+        save()
+      }
+    }
+  }
+  if (currentKey) save()
+
+  return result
+}

package/src/helpers/process-compose-env.ts

@@ -0,0 +1,57 @@
+import fs from 'node:fs'
+
+// make values safe for yaml map syntax (KEY: value)
+// handles multi-line values, special chars that break yaml parsing
+function yamlSafe(value: string): string {
+  const needsQuoting =
+    value.includes('\n') ||
+    value.includes(':') ||
+    value.includes('#') ||
+    value.startsWith('-') ||
+    value.startsWith('{') ||
+    value.startsWith('[') ||
+    value.startsWith('"') ||
+    value.startsWith("'")
+
+  if (!needsQuoting) return value
+
+  // escape backslashes and double quotes, collapse newlines
+  const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n')
+
+  return `"${escaped}"`
+}
+
+/**
+ * processes docker-compose file, replacing ${VAR:-default} with actual env values.
+ * handles multi-line values (PEM keys etc) by escaping newlines for yaml.
+ */
+export function processComposeEnv(
+  composeFile: string,
+  outputFile: string,
+  envVars: Record<string, string | undefined>
+): void {
+  let content = fs.readFileSync(composeFile, 'utf-8')
+
+  // replace all ${VAR:-default} patterns with actual env values
+  content = content.replace(
+    /\$\{([A-Z_][A-Z0-9_]*):-([^}]*)\}/g,
+    (_match, varName, defaultValue) => {
+      const value = envVars[varName]
+      if (value) {
+        console.info(
+          `  ${varName}: ${value.slice(0, 50)}${value.length > 50 ? '...' : ''}`
+        )
+      }
+      return value ? yamlSafe(value) : defaultValue
+    }
+  )
+
+  // replace standalone ${VAR} patterns
+  content = content.replace(/\$\{([A-Z_][A-Z0-9_]*)\}/g, (_match, varName) => {
+    const value = envVars[varName]
+    return value ? yamlSafe(value) : _match
+  })
+
+  fs.writeFileSync(outputFile, content)
+  console.info(`✅ processed compose file: ${outputFile}`)
+}

package/src/helpers/resolve-dep-version.ts

@@ -0,0 +1,11 @@
+/**
+ * resolves a `$dep:package-name` value to the installed version from dependencies
+ */
+export function resolveDepVersion(
+  value: string | boolean,
+  dependencies: Record<string, string> | undefined
+): string | undefined {
+  if (typeof value !== 'string' || !value.startsWith('$dep:')) return undefined
+  const depName = value.slice('$dep:'.length)
+  return dependencies?.[depName]?.replace(/^[\^~]/, '')
+}