@o/scripts 0.16.19

package/src/helpers/uncloud.ts

@@ -0,0 +1,197 @@
+import fs from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+import { run } from './run'
+
+export interface UncloudConfig {
+  context?: string
+}
+
+function ucCmd(config?: UncloudConfig): string {
+  return config?.context ? `uc -c ${config.context}` : 'uc'
+}
+
+export async function checkUncloudCLI(): Promise<void> {
+  try {
+    // uc has no --version flag; `uc version` is the cobra subcommand
+    const { stdout } = await run('uc version', { silent: true, captureOutput: true })
+    console.info(`✅ uncloud cli installed (${stdout.trim().split('\n')[0]})`)
+  } catch (error) {
+    throw new Error(
+      `uncloud cli check failed (install: curl -fsS https://get.uncloud.run/install.sh | sh): ${error}`
+    )
+  }
+}
+
+function ensureUncloudContext(host: string, sshKey: string, contextName: string): void {
+  const configDir = join(homedir(), '.config', 'uncloud')
+  const configPath = join(configDir, 'config.yaml')
+
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true })
+  }
+
+  // check if config already has context pointing to correct host
+  if (fs.existsSync(configPath)) {
+    const existing = fs.readFileSync(configPath, 'utf-8')
+    const hostname = host.split('@')[1]
+    if (hostname && existing.includes(`${contextName}:`) && existing.includes(hostname)) {
+      console.info(`✅ uncloud config already has ${contextName} context for ${host}`)
+      return
+    }
+  }
+
+  // only create config if it doesn't exist - don't overwrite existing config
+  // which may have other contexts
+  if (!fs.existsSync(configPath)) {
+    const config = `current_context: ${contextName}
+contexts:
+  ${contextName}:
+    connections:
+      - ssh: ${host}
+        ssh_key_file: ${sshKey}
+`
+    fs.writeFileSync(configPath, config)
+    console.info(`✅ created uncloud config at ${configPath}`)
+  } else {
+    console.info(`✅ using existing uncloud config (context: ${contextName})`)
+  }
+}
+
+export async function initUncloud(
+  host: string,
+  sshKey: string,
+  options: { noDNS?: boolean; noCaddy?: boolean; context?: string } = {}
+): Promise<void> {
+  console.info('\n🚀 initializing uncloud...\n')
+
+  const uc = ucCmd(options)
+  const contextName = options.context || 'default'
+
+  // check if we already have local context that works
+  try {
+    await run(`${uc} ls`, { silent: true })
+    console.info('✅ local cluster context exists and connected')
+    return
+  } catch {
+    // no local context - check if server has uncloud running
+  }
+
+  const sshCmd = `ssh -i ${sshKey} -o StrictHostKeyChecking=no ${host}`
+
+  // check if server already has uncloud daemon running
+  let serverHasUncloud = false
+  try {
+    await run(`${sshCmd} "systemctl is-active uncloud.service"`, { silent: true })
+    serverHasUncloud = true
+    console.info('✅ server has uncloud daemon running')
+  } catch {
+    try {
+      await run(`${sshCmd} "test -f /usr/local/bin/uncloudd"`, { silent: true })
+      serverHasUncloud = true
+      console.info('✅ server has uncloud installed')
+    } catch {
+      // server doesn't have uncloud - needs fresh init
+    }
+  }
+
+  if (serverHasUncloud) {
+    ensureUncloudContext(host, sshKey, contextName)
+    console.info('   (skipping init to avoid cluster reset)')
+    return
+  }
+
+  // fresh server - need to initialize
+  console.info('📦 uncloud not installed on server - initializing...')
+
+  const flags: string[] = []
+  if (options.noDNS) flags.push('--no-dns')
+  if (options.noCaddy) flags.push('--no-caddy')
+  const flagStr = flags.join(' ')
+
+  await run(`echo "y" | uc machine init ${host} -i ${sshKey} ${flagStr}`)
+
+  console.info('✅ uncloud initialized')
+}
+
+export async function pushImage(
+  imageName: string,
+  config?: UncloudConfig
+): Promise<void> {
+  console.info('\n📤 pushing image to cluster...\n')
+
+  await run(`${ucCmd(config)} image push ${imageName}`)
+  console.info('✅ image pushed')
+}
+
+export async function deployStack(
+  composeFile: string,
+  options?: { profile?: string; service?: string; recreate?: boolean } & UncloudConfig
+): Promise<void> {
+  const service = options?.service
+  console.info(`\n📦 deploying ${service ?? 'stack'}...\n`)
+
+  const profileFlag = options?.profile ? `--profile ${options.profile}` : ''
+  // --recreate forces fresh containers even when config is unchanged (picks up the new
+  // :latest image). pass recreate:false to let uncloud restart a service ONLY when its
+  // image/config actually changed — used for zero, whose restarts drop every websocket
+  // connection and cause a client reconnect storm.
+  const recreateFlag = options?.recreate === false ? '' : '--recreate'
+  const serviceArg = service ? ` ${service}` : ''
+  await run(
+    `${ucCmd(options)} deploy -f ${composeFile} ${profileFlag} ${recreateFlag} --yes${serviceArg}`
+  )
+
+  console.info('\n✅ deployment complete!')
+}
+
+export async function showStatus(config?: UncloudConfig): Promise<void> {
+  console.info('\n📊 deployment status:\n')
+
+  try {
+    await run(`${ucCmd(config)} ls`)
+  } catch {
+    console.error('could not fetch status')
+  }
+}
+
+export async function showContainers(config?: UncloudConfig): Promise<void> {
+  console.info('\n📦 container status:\n')
+
+  try {
+    await run(`${ucCmd(config)} ps`)
+  } catch {
+    console.error('could not fetch container status')
+  }
+}
+
+export async function startService(
+  service?: string,
+  config?: UncloudConfig
+): Promise<void> {
+  const target = service || 'all services'
+  console.info(`\n▶️  starting ${target}...\n`)
+
+  try {
+    await run(`${ucCmd(config)} start${service ? ` ${service}` : ''}`)
+    console.info(`✅ ${target} started`)
+  } catch {
+    throw new Error(`failed to start ${target}`)
+  }
+}
+
+export async function stopService(
+  service?: string,
+  config?: UncloudConfig
+): Promise<void> {
+  const target = service || 'all services'
+  console.info(`\n⏹️  stopping ${target}...\n`)
+
+  try {
+    await run(`${ucCmd(config)} stop${service ? ` ${service}` : ''}`)
+    console.info(`✅ ${target} stopped`)
+  } catch {
+    throw new Error(`failed to stop ${target}`)
+  }
+}

package/src/helpers/wait-for-port.ts

@@ -0,0 +1,33 @@
+import { checkPort } from './check-port'
+
+interface WaitForPortOptions {
+  host?: string
+  intervalMs?: number
+  timeoutMs?: number
+  retries?: number
+}
+
+export async function waitForPort(
+  port: number,
+  options: WaitForPortOptions = {}
+): Promise<void> {
+  const {
+    host = '127.0.0.1',
+    intervalMs = 1000,
+    timeoutMs = 30000,
+    retries = Math.floor(timeoutMs / intervalMs),
+  } = options
+
+  for (let i = 0; i < retries; i++) {
+    const isOpen = await checkPort(port, host)
+    if (isOpen) {
+      return
+    }
+
+    if (i < retries - 1) {
+      await new Promise((resolve) => setTimeout(resolve, intervalMs))
+    }
+  }
+
+  throw new Error(`Port ${port} on ${host} did not become available after ${timeoutMs}ms`)
+}

package/src/helpers/zero-get-version.ts

@@ -0,0 +1,8 @@
+import fs from 'node:fs'
+import { join } from 'node:path'
+
+export function getZeroVersion() {
+  const packageJsonPath = join(process.cwd(), 'package.json')
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
+  return packageJson.dependencies?.['@rocicorp/zero']?.replace(/^[\^~]/, '')
+}