@o/scripts 0.16.19-canary.1790165522484

package/src/env-update.ts

@@ -0,0 +1,342 @@
+#!/usr/bin/env bun
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+import { cmd } from './cmd'
+
+const PRESETS: Record<string, string[]> = {
+  takeout: ['.github/workflows/*.yml', 'src/uncloud/*.yml', '.env*'],
+}
+
+const IGNORE_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  '.next',
+  '.cache',
+  '.docker',
+])
+
+await cmd`sync environment variables from src/env.ts to matching files`
+  .args('--preset string')
+  .run(async ({ args }) => {
+    // import env var definitions from src/env.ts (the single source of truth)
+    const envModule = await import(path.resolve('src/env.ts'))
+    const production = envModule.production as Record<string, string | symbol>
+    const versions = (envModule.versions || {}) as Record<string, string>
+
+    if (!production || typeof production !== 'object') {
+      console.error('no production export found in src/env.ts')
+      process.exit(1)
+    }
+
+    // the expected symbol from @o/env
+    const expectedSymbol = Symbol.for('take-out/env/expected')
+
+    // merge resolved versions into the var registry
+    const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'))
+    const depResolved = { ...versions }
+    for (const [key, value] of Object.entries(versions)) {
+      production[key] = value
+    }
+
+    // normalize: expected symbol → required, string → defaultValue
+    type EnvEntry = { key: string; required: boolean; defaultValue: string }
+    const entries: EnvEntry[] = Object.entries(production)
+      .map(([key, value]) => ({
+        key,
+        required: value === expectedSymbol,
+        defaultValue: typeof value === 'string' ? value : '',
+      }))
+      .sort((a, b) => a.key.localeCompare(b.key))
+
+    // load .gitignore patterns
+    const gitignorePatterns: string[] = []
+    try {
+      const gi = fs.readFileSync('.gitignore', 'utf-8')
+      for (const line of gi.split('\n')) {
+        const trimmed = line.trim()
+        if (trimmed && !trimmed.startsWith('#')) {
+          gitignorePatterns.push(trimmed.replace(/\/$/, ''))
+        }
+      }
+    } catch {}
+
+    function isIgnored(filePath: string): boolean {
+      const parts = filePath.split('/')
+      for (const part of parts) {
+        if (IGNORE_DIRS.has(part)) return true
+      }
+      for (const pattern of gitignorePatterns) {
+        if (filePath.startsWith(pattern) || parts.some((p) => p === pattern)) {
+          return true
+        }
+      }
+      return false
+    }
+
+    // simple glob: supports *.ext, dir/*.ext, dir/**/*.ext, .prefix*
+    function expandPattern(pattern: string): string[] {
+      const results: string[] = []
+
+      if (!pattern.includes('*')) {
+        if (fs.existsSync(pattern)) results.push(pattern)
+        return results
+      }
+
+      const isRecursive = pattern.includes('**')
+      const parts = pattern.split('**/')
+      const baseDir = parts.length > 1 ? parts[0]!.replace(/\/$/, '') || '.' : '.'
+      const filePattern =
+        parts.length > 1
+          ? parts[1]!
+          : pattern.includes('/')
+            ? pattern.split('/').pop()!
+            : pattern
+
+      // for non-recursive patterns with a dir prefix like "src/uncloud/*.yml"
+      const nonRecursiveDir =
+        !isRecursive && pattern.includes('/')
+          ? pattern.slice(0, pattern.lastIndexOf('/'))
+          : null
+
+      const matchRe = new RegExp(
+        '^' + filePattern.replace(/\./g, '\\.').replace(/\*/g, '[^/]*') + '$'
+      )
+
+      function walk(dir: string) {
+        let dirEntries: fs.Dirent[]
+        try {
+          dirEntries = fs.readdirSync(dir, { withFileTypes: true })
+        } catch {
+          return
+        }
+        for (const entry of dirEntries) {
+          const full = dir === '.' ? entry.name : `${dir}/${entry.name}`
+          if (isRecursive && isIgnored(full)) continue
+          if (entry.isDirectory()) {
+            if (isRecursive) walk(full)
+          } else if (matchRe.test(entry.name)) {
+            results.push(full)
+          }
+        }
+      }
+
+      walk(nonRecursiveDir || baseDir)
+      return results
+    }
+
+    // resolve file list: --preset > CLI args > package.json config > preset:takeout
+    let patterns: string[]
+    if (args.preset) {
+      const preset = PRESETS[args.preset]
+      if (!preset) {
+        console.error(
+          `Unknown preset: ${args.preset}\nAvailable: ${Object.keys(PRESETS).join(', ')}`
+        )
+        process.exit(1)
+      }
+      patterns = preset
+    } else if (args.rest.length) {
+      patterns = args.rest
+    } else {
+      patterns = packageJson.envUpdateFiles || PRESETS.takeout!
+    }
+
+    // expand all patterns
+    const files: string[] = []
+    for (const p of patterns) {
+      files.push(...expandPattern(p))
+    }
+
+    // ensure .env is always processed (may not exist yet for fresh projects)
+    if (!files.includes('.env')) {
+      files.push('.env')
+    }
+
+    // markers
+    const markerStart = '🔒 start - this is generated by "bun env:update"'
+    const markerEnd = '🔒 end - this is generated by "bun env:update"'
+    const yamlStart = `# ${markerStart}`
+    const yamlEnd = `# ${markerEnd}`
+    // .env auto-generated section markers
+    const dotenvSectionStart = '# ---- BEGIN AUTO-GENERATED (DO NOT EDIT) ----'
+    const dotenvSectionEnd = '# ---- END AUTO-GENERATED ----'
+    const typescriptArrayStart = '// 🔒 env array start - generated by "bun env:update"'
+    const typescriptArrayEnd = '// 🔒 env array end - generated by "bun env:update"'
+
+    type Strategy =
+      | 'yaml-markers'
+      | 'dotenv-section'
+      | 'dotenv-inline'
+      | 'typescript-array-markers'
+
+    function detectStrategy(filePath: string, content: string): Strategy | null {
+      if (content.includes(yamlStart) && content.includes(yamlEnd)) {
+        return 'yaml-markers'
+      }
+      if (
+        content.includes(typescriptArrayStart) &&
+        content.includes(typescriptArrayEnd)
+      ) {
+        return 'typescript-array-markers'
+      }
+      const basename = path.basename(filePath)
+      if (basename === '.env') {
+        return 'dotenv-section'
+      }
+      if (/^\.env/.test(basename) && Object.keys(depResolved).length > 0) {
+        return 'dotenv-inline'
+      }
+      return null
+    }
+
+    function escapeRegExp(s: string): string {
+      return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    }
+
+    function replaceMarkerSection(
+      content: string,
+      startMarker: string,
+      endMarker: string,
+      newSection: string
+    ): string {
+      const re = new RegExp(
+        `^([ \\t]*)${escapeRegExp(startMarker)}(.|\n)*?${escapeRegExp(endMarker)}`,
+        'gm'
+      )
+      return content.replace(re, (_match, indent) => {
+        return `${indent}${startMarker}\n${newSection}\n${indent}${endMarker}`
+      })
+    }
+
+    function applyYamlMarkers(filePath: string, content: string): string {
+      const markerMatch = content.match(
+        new RegExp(`^(\\s*)${escapeRegExp(yamlStart)}`, 'm')
+      )
+      const indent = markerMatch?.[1] || '      '
+
+      const beforeMarker = content.slice(0, content.indexOf(yamlStart))
+      const isMap = /x-[\w-]+:.*&[\w-]+/s.test(beforeMarker)
+      const isGithubActions = filePath.includes('.github/workflows')
+
+      const envLines = entries
+        .map(({ key, defaultValue }) => {
+          const dep = depResolved[key]
+          const val = dep || defaultValue
+
+          if (isGithubActions) {
+            // deps-derived versions track package.json — emit a literal so a
+            // stale repo secret can never shadow them (a stale ZERO_VERSION
+            // secret once pinned an old zero-cache protocol against a newer
+            // client). matches the .env codegen below, which already does this.
+            return dep
+              ? `${indent}${key}: '${dep}'`
+              : `${indent}${key}: \${{ secrets.${key} }}`
+          }
+
+          return isMap
+            ? `${indent}${key}: \${${key}:-${val}}`
+            : `${indent}- ${key}=\${${key}:-${val}}`
+        })
+        .join('\n')
+
+      return replaceMarkerSection(content, yamlStart, yamlEnd, envLines)
+    }
+
+    function applyDotenvSection(_filePath: string, content: string): string {
+      const lines: string[] = [dotenvSectionStart]
+
+      for (const { key, required, defaultValue } of entries) {
+        const dep = depResolved[key]
+        if (dep) {
+          lines.push(`${key}=${dep}`)
+        } else if (!required && defaultValue !== '') {
+          lines.push(`${key}=${defaultValue}`)
+        }
+      }
+
+      lines.push(dotenvSectionEnd)
+      const section = lines.join('\n')
+
+      const beginIndex = content.indexOf(dotenvSectionStart)
+      const endIndex = content.indexOf(dotenvSectionEnd)
+
+      if (beginIndex !== -1 && endIndex !== -1 && endIndex > beginIndex) {
+        const before = content.substring(0, beginIndex).trimEnd()
+        const after = content.substring(endIndex + dotenvSectionEnd.length).trimStart()
+        return [before, section, after].filter(Boolean).join('\n\n')
+      }
+
+      // no existing section — append
+      const trimmed = content.trimEnd()
+      return trimmed ? `${trimmed}\n\n${section}` : section
+    }
+
+    function applyDotenvInline(_filePath: string, content: string): string {
+      let result = content
+      for (const [key, value] of Object.entries(depResolved)) {
+        const re = new RegExp(`^(${key})=(.+)$`, 'm')
+        const match = result.match(re)
+        if (match && match[2] !== value) {
+          result = result.replace(re, `$1=${value}`)
+        }
+      }
+      return result
+    }
+
+    function applyTypescriptArrayMarkers(_filePath: string, content: string): string {
+      const markerMatch = content.match(
+        new RegExp(`^(\\s*)${escapeRegExp(typescriptArrayStart)}`, 'm')
+      )
+      const indent = markerMatch?.[1] || '  '
+      const envLines = entries.map(({ key }) => `${indent}'${key}',`).join('\n')
+      return replaceMarkerSection(
+        content,
+        typescriptArrayStart,
+        typescriptArrayEnd,
+        envLines
+      )
+    }
+
+    const strategies: Record<Strategy, (filePath: string, content: string) => string> = {
+      'yaml-markers': applyYamlMarkers,
+      'dotenv-section': applyDotenvSection,
+      'dotenv-inline': applyDotenvInline,
+      'typescript-array-markers': applyTypescriptArrayMarkers,
+    }
+
+    let updated = 0
+
+    for (const filePath of files) {
+      let content = ''
+      try {
+        content = fs.readFileSync(filePath, 'utf-8')
+      } catch {
+        // allow .env to be created from scratch
+        if (path.basename(filePath) === '.env') {
+          content = ''
+        } else {
+          continue
+        }
+      }
+
+      const strategy = detectStrategy(filePath, content)
+      if (!strategy) continue
+
+      const newContent = strategies[strategy](filePath, content)
+      if (newContent !== content) {
+        fs.writeFileSync(filePath, newContent, 'utf-8')
+        console.info(`✅ ${filePath} (${strategy})`)
+        updated++
+      }
+    }
+
+    if (updated > 0) {
+      console.info(`\n✅ Updated ${updated} file${updated > 1 ? 's' : ''}`)
+    } else {
+      console.info('All files up to date')
+    }
+  })

package/src/exec-with-env.ts

@@ -0,0 +1,61 @@
+#!/usr/bin/env bun
+
+import { ensureExists } from '@o/helpers'
+
+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('./ensure-tunnel')
+    const { getEnvironment } = await import('./sst-get-environment')
+    envFileEnv = getEnvironment(process.env.REMOTE)
+    ensureExists(envFileEnv)
+  } else {
+    envFileEnv = await loadEnv(environment)
+  }
+
+  console.info(
+    `($): ${command} | env ${environment} ${USE_LOCAL_SERVER ? '| using local endpoints' : ''}`
+  )
+
+  const devEnv = USE_LOCAL_SERVER ? await loadEnv('development') : null
+
+  const env = {
+    ...envFileEnv,
+    ...process.env,
+    // running local server but hitting most prod endpoints except auth
+    ...(USE_LOCAL_SERVER && {
+      ONE_SERVER_URL: devEnv?.ONE_SERVER_URL,
+      // vite reads from .env.production for us unless defined into process.env
+      VITE_ZERO_HOSTNAME: 'start.chat',
+    }),
+  } as any as Record<string, string>
+
+  const parts = command.split(' ')
+  return spawnSync(parts[0]!, parts.slice(1), {
+    stdio: ['ignore', 'inherit', 'inherit'],
+    env,
+  })
+}
+
+if (import.meta.main) {
+  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)
+    }
+  )
+}

package/src/helpers/args.ts

@@ -0,0 +1,97 @@
+/**
+ * ultra simple typed arg parsing
+ *
+ * @example
+ * const { port, verbose, rest } = args`--port number --verbose boolean`
+ * // port: number | undefined
+ * // verbose: boolean
+ * // rest: string[] - positional args that don't match any flag
+ */
+
+type ParseType<T extends string> = T extends 'number'
+  ? number | undefined
+  : T extends 'boolean'
+    ? boolean
+    : T extends 'string'
+      ? string | undefined
+      : never
+
+type ParseFlag<S extends string> = S extends `--${infer Name} ${infer Type}`
+  ? { [K in Name as KebabToCamel<K>]: ParseType<Type> }
+  : S extends `-${infer Name} ${infer Type}`
+    ? { [K in Name as KebabToCamel<K>]: ParseType<Type> }
+    : object
+
+type KebabToCamel<S extends string> = S extends `${infer A}-${infer B}`
+  ? `${A}${Capitalize<KebabToCamel<B>>}`
+  : S
+
+// trim leading/trailing whitespace from string type
+type Trim<S extends string> = S extends ` ${infer R}`
+  ? Trim<R>
+  : S extends `${infer R} `
+    ? Trim<R>
+    : S extends `\n${infer R}`
+      ? Trim<R>
+      : S extends `${infer R}\n`
+        ? Trim<R>
+        : S
+
+// split on -- allowing any whitespace between flags
+type ParseFlags<S extends string> =
+  Trim<S> extends `${infer Flag} --${infer Rest}`
+    ? ParseFlag<Trim<Flag>> & ParseFlags<`--${Rest}`>
+    : Trim<S> extends `${infer Flag}\n--${infer Rest}`
+      ? ParseFlag<Trim<Flag>> & ParseFlags<`--${Rest}`>
+      : Trim<S> extends `${infer Flag} -${infer Rest}`
+        ? ParseFlag<Trim<Flag>> & ParseFlags<`-${Rest}`>
+        : Trim<S> extends `${infer Flag}\n-${infer Rest}`
+          ? ParseFlag<Trim<Flag>> & ParseFlags<`-${Rest}`>
+          : ParseFlag<Trim<S>>
+
+// flatten intersection into single object for nice hover display
+type Prettify<T> = { [K in keyof T]: T[K] } & {}
+
+export type Args<S extends string> = Prettify<ParseFlags<S> & { rest: string[] }>
+
+export function args<const S extends string>(spec: S): Args<S>
+export function args<const S extends string>(strings: TemplateStringsArray | S): Args<S> {
+  const spec = typeof strings === 'string' ? strings : strings[0] || ''
+  const argv = process.argv.slice(2)
+
+  // parse spec: "--port number --verbose boolean"
+  const schema: Record<string, 'string' | 'number' | 'boolean'> = {}
+  const matches = spec.matchAll(/--?([a-z0-9-]+)\s+(string|number|boolean)/gi)
+
+  for (const [, flag, type] of matches) {
+    const camel = flag!.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase())
+    schema[camel] = type as 'string' | 'number' | 'boolean'
+  }
+
+  const result: Record<string, string | number | boolean | undefined> = {}
+  const rest: string[] = []
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i]!
+
+    if (arg.startsWith('-')) {
+      const key = arg
+        .replace(/^--?/, '')
+        .replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase())
+      const type = schema[key]
+
+      if (type === 'boolean') {
+        result[key] = true
+      } else if (type === 'string' || type === 'number') {
+        const val = argv[++i]
+        result[key] = type === 'number' ? Number(val) : val
+      } else {
+        rest.push(arg)
+      }
+    } else {
+      rest.push(arg)
+    }
+  }
+
+  return { ...result, rest } as Args<S>
+}

package/src/helpers/check-port.ts

@@ -0,0 +1,22 @@
+import { Socket } from 'node:net'
+
+export function checkPort(port: number, host = '127.0.0.1'): Promise<boolean> {
+  return new Promise((resolve) => {
+    const tester = new Socket()
+
+    tester.once('connect', () => {
+      tester.destroy()
+      resolve(true)
+    })
+
+    tester.once('error', (err: NodeJS.ErrnoException) => {
+      if (err.code === 'ECONNREFUSED') {
+        resolve(false)
+      } else {
+        resolve(true)
+      }
+    })
+
+    tester.connect(port, host)
+  })
+}