@take-out/scripts 0.0.93 → 0.0.94

package/src/ensure-port.ts

@@ -1,87 +1,79 @@
 #!/usr/bin/env bun
 
-/**
- * @description Ensure a port is available, exit with error if in use
- * @args --auto-kill <prefix>
- */
+import { cmd } from './cmd'
 
-import { execSync } from 'node:child_process'
+await cmd`ensure a port is available, exit with error if in use`
+  .args('--auto-kill string')
+  .run(async ({ args }) => {
+    const { execSync } = await import('node:child_process')
 
-import { args } from './helpers/args'
+    const port = args.rest[0]
 
-const { autoKill, _ } = args('--auto-kill string')
-
-const port = _[0]
-
-if (!port) {
-  console.error('usage: bun tko ensure-port <port> [--auto-kill <prefix>]')
-  process.exit(1)
-}
-
-const portNum = Number.parseInt(port, 10)
+    if (!port) {
+      console.error('usage: bun tko ensure-port <port> [--auto-kill <prefix>]')
+      process.exit(1)
+    }
 
-if (Number.isNaN(portNum) || portNum < 1 || portNum > 65535) {
-  console.error(`invalid port: ${port}`)
-  process.exit(1)
-}
+    const portNum = Number.parseInt(port, 10)
 
-function getListeningProcess(p: number): { pid?: number; command?: string } {
-  try {
-    // use -sTCP:LISTEN to only find processes LISTENING on the port (servers)
-    // not clients connected to it
-    const output = execSync(`lsof -i :${p} -sTCP:LISTEN -t`, {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'ignore'],
-    }).trim()
+    if (Number.isNaN(portNum) || portNum < 1 || portNum > 65535) {
+      console.error(`invalid port: ${port}`)
+      process.exit(1)
+    }
 
-    if (!output) return {}
+    function getListeningProcess(p: number): { pid?: number; command?: string } {
+      try {
+        // use -sTCP:LISTEN to only find processes LISTENING on the port (servers)
+        const output = execSync(`lsof -i :${p} -sTCP:LISTEN -t`, {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim()
 
-    const pid = Number.parseInt(output.split('\n')[0] || '', 10)
-    if (Number.isNaN(pid)) return {}
+        if (!output) return {}
 
-    // get command name
-    const ps = execSync(`ps -p ${pid} -o comm=`, {
-      encoding: 'utf-8',
-      stdio: ['pipe', 'pipe', 'ignore'],
-    }).trim()
+        const pid = Number.parseInt(output.split('\n')[0] || '', 10)
+        if (Number.isNaN(pid)) return {}
 
-    return { pid, command: ps }
-  } catch {
-    return {}
-  }
-}
+        const ps = execSync(`ps -p ${pid} -o comm=`, {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim()
 
-function killProcess(pid: number): boolean {
-  try {
-    execSync(`kill ${pid}`, { stdio: 'ignore' })
-    return true
-  } catch {
-    return false
-  }
-}
+        return { pid, command: ps }
+      } catch {
+        return {}
+      }
+    }
 
-const { pid, command } = getListeningProcess(portNum)
+    function killProcess(pid: number): boolean {
+      try {
+        execSync(`kill ${pid}`, { stdio: 'ignore' })
+        return true
+      } catch {
+        return false
+      }
+    }
 
-if (pid) {
-  // check if we should auto-kill this process
-  if (autoKill && command?.startsWith(autoKill)) {
-    console.info(`killing ${command} (pid ${pid}) on port ${portNum}`)
-    if (killProcess(pid)) {
-      // give it a moment to release the port
-      Bun.sleepSync(100)
-      // verify it's gone
-      const check = getListeningProcess(portNum)
-      if (!check.pid) {
-        process.exit(0)
+    const { pid, command } = getListeningProcess(portNum)
+
+    if (pid) {
+      if (args.autoKill && command?.startsWith(args.autoKill)) {
+        console.info(`killing ${command} (pid ${pid}) on port ${portNum}`)
+        if (killProcess(pid)) {
+          Bun.sleepSync(100)
+          const check = getListeningProcess(portNum)
+          if (!check.pid) {
+            process.exit(0)
+          }
+          console.error(`failed to free port ${portNum}`)
+          process.exit(1)
+        }
+        console.error(`failed to kill pid ${pid}`)
+        process.exit(1)
       }
-      console.error(`failed to free port ${portNum}`)
+
+      console.error(`port ${portNum} in use by ${command || 'unknown'} (pid ${pid})`)
+      console.error(`run: kill ${pid}`)
       process.exit(1)
     }
-    console.error(`failed to kill pid ${pid}`)
-    process.exit(1)
-  }
-
-  console.error(`port ${portNum} in use by ${command || 'unknown'} (pid ${pid})`)
-  console.error(`run: kill ${pid}`)
-  process.exit(1)
-}
+  })

package/src/ensure-tunnel.ts

@@ -1,15 +1,19 @@
 #!/usr/bin/env bun
 
-import { spawnSync } from 'node:child_process'
-
-const netstat = spawnSync('netstat', ['-rn'], { encoding: 'utf-8' }).stdout || ''
-const isTunnelActive = netstat.includes(`10.0.8/22`)
-
-if (!isTunnelActive) {
-  console.error(`No tunnel active, run bun sst:tunnel:production first`)
-  process.exit(1)
-}
+import { cmd } from './cmd'
 
 export function ensureEnv() {
   // make it a module
 }
+
+await cmd`check if SST production tunnel is active`.run(async () => {
+  const { spawnSync } = await import('node:child_process')
+
+  const netstat = spawnSync('netstat', ['-rn'], { encoding: 'utf-8' }).stdout || ''
+  const isTunnelActive = netstat.includes(`10.0.8/22`)
+
+  if (!isTunnelActive) {
+    console.error(`No tunnel active, run bun sst:tunnel:production first`)
+    process.exit(1)
+  }
+})

package/src/env-pull.ts

@@ -1,55 +1,57 @@
 #!/usr/bin/env bun
 
-import { existsSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { getEnvironment } from './sst-get-environment'
-
-const rootDir = process.cwd()
-
-const envFilePath = join(rootDir, '.env.production')
-if (existsSync(envFilePath)) {
-  console.error(
-    '❌ Error: .env.production already exists. Please remove or rename it first.'
-  )
-  process.exit(1)
-}
-
-const packageJson = require(join(rootDir, 'package.json'))
-const envVarsNeeded = packageJson.env ? Object.keys(packageJson.env) : []
-if (!envVarsNeeded.length) {
-  console.error(
-    `❌ Error: No environment variables specified in package.json 'env' array.`
-  )
-  process.exit(1)
-}
-
-try {
-  const envVars = getEnvironment('WebApp')
-
-  let envFileContent = ''
-  let foundCount = 0
-
-  for (const varName of envVarsNeeded) {
-    if (envVars[varName] !== undefined) {
-      envFileContent += `${varName}=${envVars[varName]}\n`
-      foundCount++
-    } else {
-      console.warn(`⚠️  Warning: Didn't find env: ${varName}`)
-    }
+import { cmd } from './cmd'
+
+await cmd`pull environment variables from SST production`.run(async ({ path }) => {
+  const { existsSync, writeFileSync } = await import('node:fs')
+  const { getEnvironment } = await import('./sst-get-environment')
+
+  const rootDir = process.cwd()
+
+  const envFilePath = path.join(rootDir, '.env.production')
+  if (existsSync(envFilePath)) {
+    console.error(
+      '❌ Error: .env.production already exists. Please remove or rename it first.'
+    )
+    process.exit(1)
   }
 
-  if (foundCount === 0) {
-    console.error(`❌ Error: None of the required environment variables were found.`)
+  const packageJson = require(path.join(rootDir, 'package.json'))
+  const envVarsNeeded = packageJson.env ? Object.keys(packageJson.env) : []
+  if (!envVarsNeeded.length) {
+    console.error(
+      `❌ Error: No environment variables specified in package.json 'env' array.`
+    )
     process.exit(1)
   }
 
-  writeFileSync(envFilePath, envFileContent)
+  try {
+    const envVars = getEnvironment('WebApp')
+
+    let envFileContent = ''
+    let foundCount = 0
 
-  console.info(
-    `✅ Success! ${foundCount} environment variables written to .env.production`
-  )
-} catch (error) {
-  console.error('❌ Error fetching environment variables:', error)
-  process.exit(1)
-}
+    for (const varName of envVarsNeeded) {
+      if (envVars[varName] !== undefined) {
+        envFileContent += `${varName}=${envVars[varName]}\n`
+        foundCount++
+      } else {
+        console.warn(`⚠️  Warning: Didn't find env: ${varName}`)
+      }
+    }
+
+    if (foundCount === 0) {
+      console.error(`❌ Error: None of the required environment variables were found.`)
+      process.exit(1)
+    }
+
+    writeFileSync(envFilePath, envFileContent)
+
+    console.info(
+      `✅ Success! ${foundCount} environment variables written to .env.production`
+    )
+  } catch (error) {
+    console.error('❌ Error fetching environment variables:', error)
+    process.exit(1)
+  }
+})

package/src/env-update.ts

@@ -1,180 +1,148 @@
 #!/usr/bin/env bun
 
-/**
- * Environment Variable Management Script
- *
- * This script reads the environment variables defined in package.json
- * and updates the necessary files with the correct environment variables.
- *
- * Files updated:
- * - .github/workflows/deploy.yml - GitHub Actions environment variables
- * - src/constants/env-server.ts - Server environment variables
- * - Dockerfile - Docker build ARG definitions
- */
-
-import { readFileSync, writeFileSync } from 'node:fs'
-
-const packageJson = JSON.parse(readFileSync('package.json', 'utf-8'))
-const envVars = packageJson.env as Record<string, boolean | string>
-
-if (!envVars || Array.isArray(envVars) || typeof envVars !== 'object') {
-  console.error('No environment variables found in package.json')
-  process.exit(1)
-}
-
-const markerStart = '🔒 start - this is generated by "bun env:update"'
-const markerEnd = '🔒 end - this is generated by "bun env:update"'
-
-const yamlStartMarker = `# ${markerStart}`
-const yamlEndMarker = `# ${markerEnd}`
-
-const jsStartMarker = `// ${markerStart}`
-const jsEndMarker = `// ${markerEnd}`
-
-function replaceYamlSection(
-  content: string,
-  lines: string,
-  options: { indent: string }
-): string {
-  return content.replace(
-    new RegExp(`${yamlStartMarker}(.|\n)*?${yamlEndMarker}`, 'gm'),
-    `${yamlStartMarker}\n${lines}\n${options.indent}${yamlEndMarker}`
-  )
-}
-
-function updateDeployYml() {
-  const deployYmlPath = '.github/workflows/ci.yml'
-  let deployYml = readFileSync(deployYmlPath, 'utf-8')
-
-  if (!deployYml.includes(yamlStartMarker) || !deployYml.includes(yamlEndMarker)) {
-    throw new Error(`Markers not found in ${deployYmlPath}`)
-  }
-
-  const indent = `          `
-  const envSection = Object.keys(envVars)
-    .map((key) => `${indent}${key}: \${{ secrets.${key} }}`)
-    .join('\n')
-
-  const newDeployYml = replaceYamlSection(deployYml, envSection, { indent })
-
-  writeFileSync(deployYmlPath, newDeployYml, 'utf-8')
-  console.info('✅ Updated Github workflow')
-}
+import { cmd } from './cmd'
+
+await cmd`sync environment variables from package.json to CI and server configs`.run(
+  async () => {
+    const { readFileSync, writeFileSync } = await import('node:fs')
+
+    const packageJson = JSON.parse(readFileSync('package.json', 'utf-8'))
+    const envVars = packageJson.env as Record<string, boolean | string>
+
+    if (!envVars || Array.isArray(envVars) || typeof envVars !== 'object') {
+      console.error('No environment variables found in package.json')
+      process.exit(1)
+    }
+
+    const markerStart = '🔒 start - this is generated by "bun env:update"'
+    const markerEnd = '🔒 end - this is generated by "bun env:update"'
+
+    const yamlStartMarker = `# ${markerStart}`
+    const yamlEndMarker = `# ${markerEnd}`
+
+    const jsStartMarker = `// ${markerStart}`
+    const jsEndMarker = `// ${markerEnd}`
+
+    function replaceYamlSection(
+      content: string,
+      lines: string,
+      options: { indent: string }
+    ): string {
+      return content.replace(
+        new RegExp(`${yamlStartMarker}(.|\n)*?${yamlEndMarker}`, 'gm'),
+        `${yamlStartMarker}\n${lines}\n${options.indent}${yamlEndMarker}`
+      )
+    }
+
+    function updateDeployYml() {
+      const deployYmlPath = '.github/workflows/ci.yml'
+      let deployYml = readFileSync(deployYmlPath, 'utf-8')
+
+      if (!deployYml.includes(yamlStartMarker) || !deployYml.includes(yamlEndMarker)) {
+        throw new Error(`Markers not found in ${deployYmlPath}`)
+      }
+
+      const indent = `          `
+      const envSection = Object.keys(envVars)
+        .map((key) => `${indent}${key}: \${{ secrets.${key} }}`)
+        .join('\n')
+
+      const newDeployYml = replaceYamlSection(deployYml, envSection, { indent })
+
+      writeFileSync(deployYmlPath, newDeployYml, 'utf-8')
+      console.info('✅ Updated Github workflow')
+    }
+
+    function updateEnvServerTs() {
+      const candidates = ['src/constants/env-server.ts', 'src/server/env-server.ts']
+      let envServerPath = ''
+      let envServer = ''
+
+      for (const p of candidates) {
+        try {
+          envServer = readFileSync(p, 'utf-8')
+          envServerPath = p
+          break
+        } catch {}
+      }
+
+      if (!envServerPath) {
+        throw new Error(`env-server.ts not found at ${candidates.join(' or ')}`)
+      }
+
+      if (!envServer.includes(jsStartMarker) || !envServer.includes(jsEndMarker)) {
+        throw new Error(`Markers not found in ${envServerPath}`)
+      }
+
+      const envExports = Object.entries(envVars)
+        .map(
+          ([key, value]) =>
+            `export const ${key} = ensureEnv('${key}'${typeof value === 'string' ? `, ${JSON.stringify(value)}` : ''})`
+        )
+        .join('\n')
+
+      const newEnvServer = envServer.replace(
+        new RegExp(`${jsStartMarker}(.|\n)*?${jsEndMarker}`, 'm'),
+        `${jsStartMarker}\n${envExports}\n${jsEndMarker}`
+      )
+
+      writeFileSync(envServerPath, newEnvServer, 'utf-8')
+      console.info('✅ Updated server env')
+    }
+
+    function updateDockerCompose() {
+      const dockerComposePath = 'src/uncloud/docker-compose.yml'
+
+      let dockerCompose = ''
+      try {
+        dockerCompose = readFileSync(dockerComposePath, 'utf-8')
+      } catch (_error) {
+        // file doesn't exist, skip
+        return
+      }
+
+      if (
+        !dockerCompose.includes(yamlStartMarker) ||
+        !dockerCompose.includes(yamlEndMarker)
+      ) {
+        // no markers, skip
+        return
+      }
+
+      // detect indent from the marker line
+      const markerMatch = dockerCompose.match(
+        new RegExp(`^(\\s*)${yamlStartMarker}`, 'm')
+      )
+      const indent = markerMatch?.[1] || '      '
+
+      // detect format: if markers are under an x- anchor block, use map syntax (KEY: val)
+      // otherwise use list syntax (- KEY=val)
+      const beforeMarker = dockerCompose.slice(
+        0,
+        dockerCompose.indexOf(yamlStartMarker)
+      )
+      const isMap = /x-[\w-]+:.*&[\w-]+/s.test(beforeMarker)
+
+      const envLines = Object.keys(envVars)
+        .map((key) =>
+          isMap ? `${indent}${key}: \${${key}:-}` : `${indent}- ${key}=\${${key}:-}`
+        )
+        .join('\n')
+
+      const newDockerCompose = replaceYamlSection(dockerCompose, envLines, { indent })
+
+      writeFileSync(dockerComposePath, newDockerCompose, 'utf-8')
+      console.info('✅ Updated docker-compose.yml')
+    }
 
-function updateEnvServerTs() {
-  const candidates = ['src/constants/env-server.ts', 'src/server/env-server.ts']
-  let envServerPath = ''
-  let envServer = ''
-
-  for (const path of candidates) {
     try {
-      envServer = readFileSync(path, 'utf-8')
-      envServerPath = path
-      break
-    } catch {}
-  }
-
-  if (!envServerPath) {
-    throw new Error(`env-server.ts not found at ${candidates.join(' or ')}`)
-  }
-
-  if (!envServer.includes(jsStartMarker) || !envServer.includes(jsEndMarker)) {
-    throw new Error(`Markers not found in ${envServerPath}`)
-  }
-
-  const envExports = Object.entries(envVars)
-    .map(
-      ([key, value]) =>
-        `export const ${key} = ensureEnv('${key}'${typeof value === 'string' ? `, ${JSON.stringify(value)}` : ''})`
-    )
-    .join('\n')
-
-  const newEnvServer = envServer.replace(
-    new RegExp(`${jsStartMarker}(.|\n)*?${jsEndMarker}`, 'm'),
-    `${jsStartMarker}\n${envExports}\n${jsEndMarker}`
-  )
-
-  writeFileSync(envServerPath, newEnvServer, 'utf-8')
-  console.info('✅ Updated server env')
-}
-
-// function updateDockerfile() {
-//   const dockerfilePath = 'Dockerfile'
-
-//   let dockerfile = ''
-//   try {
-//     dockerfile = readFileSync(dockerfilePath, 'utf-8')
-//   } catch (_error) {
-//     throw new Error(`File ${dockerfilePath} not found`)
-//   }
-
-//   if (!dockerfile.includes(yamlStartMarker) || !dockerfile.includes(yamlEndMarker)) {
-//     throw new Error(`Markers not found in ${dockerfilePath}`)
-//   }
-
-//   const dockerArgs = Object.keys(envVars)
-//     .map((env) => `ARG ${env}`)
-//     .join('\n')
-
-//   const newDockerfile = dockerfile.replace(
-//     new RegExp(`${yamlStartMarker}(.|\n)*?${yamlEndMarker}`, 'm'),
-//     `${yamlStartMarker}\n${dockerArgs}\n${yamlEndMarker}`
-//   )
-
-//   writeFileSync(dockerfilePath, newDockerfile, 'utf-8')
-//   console.info('✅ Updated Dockerfile')
-// }
-
-function updateDockerCompose() {
-  const dockerComposePath = 'src/uncloud/docker-compose.yml'
-
-  let dockerCompose = ''
-  try {
-    dockerCompose = readFileSync(dockerComposePath, 'utf-8')
-  } catch (_error) {
-    // file doesn't exist, skip
-    return
-  }
-
-  if (
-    !dockerCompose.includes(yamlStartMarker) ||
-    !dockerCompose.includes(yamlEndMarker)
-  ) {
-    // no markers, skip
-    return
-  }
-
-  // detect indent from the marker line
-  const markerMatch = dockerCompose.match(new RegExp(`^(\\s*)${yamlStartMarker}`, 'm'))
-  const indent = markerMatch?.[1] || '      '
-
-  // detect format: if markers are under an x- anchor block, use map syntax (KEY: val)
-  // otherwise use list syntax (- KEY=val)
-  const beforeMarker = dockerCompose.slice(0, dockerCompose.indexOf(yamlStartMarker))
-  const isMap = /x-[\w-]+:.*&[\w-]+/s.test(beforeMarker)
-
-  const envLines = Object.keys(envVars)
-    .map((key) =>
-      isMap ? `${indent}${key}: \${${key}:-}` : `${indent}- ${key}=\${${key}:-}`
-    )
-    .join('\n')
-
-  const newDockerCompose = replaceYamlSection(dockerCompose, envLines, { indent })
-
-  writeFileSync(dockerComposePath, newDockerCompose, 'utf-8')
-  console.info('✅ Updated docker-compose.yml')
-}
-
-async function updateAll() {
-  try {
-    updateDeployYml()
-    updateEnvServerTs()
-    updateDockerCompose()
-    console.info('✅ All files updated successfully')
-  } catch (error: any) {
-    console.error('❌ Update failed:', error.message)
-    process.exit(1)
+      updateDeployYml()
+      updateEnvServerTs()
+      updateDockerCompose()
+      console.info('✅ All files updated successfully')
+    } catch (error: any) {
+      console.error('❌ Update failed:', error.message)
+      process.exit(1)
+    }
   }
-}
-
-await updateAll()
+)

package/src/exec-with-env.ts

@@ -1,20 +1,22 @@
 #!/usr/bin/env bun
 
-import { spawnSync } from 'node:child_process'
-
 import { ensureExists } from '@take-out/helpers'
-import { loadEnv } from '@take-out/scripts/helpers/env-load'
+
+import { cmd } from './cmd'
 
 export async function execWithEnvironment(
   environment: 'development' | 'production',
   command: string
 ) {
+  const { spawnSync } = await import('node:child_process')
+  const { loadEnv } = await import('./helpers/env-load')
+
   const { USE_LOCAL_SERVER } = process.env
 
   let envFileEnv: Record<string, string>
 
   if (process.env.REMOTE) {
-    await import('@take-out/scripts/ensure-tunnel')
+    await import('./ensure-tunnel')
     const { getEnvironment } = await import('./sst-get-environment')
     envFileEnv = getEnvironment(process.env.REMOTE)
     ensureExists(envFileEnv)
@@ -36,9 +38,6 @@ export async function execWithEnvironment(
       ONE_SERVER_URL: devEnv?.ONE_SERVER_URL,
       // vite reads from .env.production for us unless defined into process.env
       VITE_PUBLIC_ZERO_SERVER: 'https://start.chat',
-      // actually we need to use prod better auth but allow localhost trusted origin, may need other env though
-      // BETTER_AUTH_SECRET: devEnv?.BETTER_AUTH_SECRET,
-      // BETTER_AUTH_URL: devEnv?.BETTER_AUTH_URL,
     }),
   } as any as Record<string, string>
 
@@ -50,9 +49,13 @@ export async function execWithEnvironment(
 }
 
 if (import.meta.main) {
-  const result = await execWithEnvironment(
-    (process.env.NODE_ENV as 'development' | 'production') || 'development',
-    process.argv.slice(3).join(' ')
+  await cmd`execute command with environment variables loaded from local or remote`.run(
+    async () => {
+      const result = await execWithEnvironment(
+        (process.env.NODE_ENV as 'development' | 'production') || 'development',
+        process.argv.slice(3).join(' ')
+      )
+      process.exit(result.status ?? 1)
+    }
   )
-  process.exit(result.status ?? 1)
 }