@o/scripts 0.16.19

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 vxrn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@o/scripts",
+  "version": "0.16.19",
+  "type": "module",
+  "main": "./src/cmd.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./src/cmd.ts",
+      "default": "./src/cmd.ts"
+    },
+    "./package.json": "./package.json",
+    "./helpers/*": {
+      "types": "./src/helpers/*.ts",
+      "default": "./src/helpers/*.ts"
+    },
+    "./*": {
+      "types": "./src/*.ts",
+      "default": "./src/*.ts"
+    }
+  },
+  "scripts": {
+    "lint": "oxlint src",
+    "lint:fix": "oxfmt src && oxlint --fix --fix-suggestions src",
+    "typecheck": "tko run typecheck"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.8.2",
+    "@o/helpers": "0.16.19",
+    "@o/run": "0.16.19",
+    "picocolors": "^1.1.1",
+    "@aws-sdk/client-s3": "^3.709.0",
+    "fs-extra": "^11.2.0",
+    "p-map": "^7.0.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/natew/orez.git",
+    "directory": "packages/scripts"
+  },
+  "files": [
+    "src"
+  ],
+  "peerDependencies": {
+    "vxrn": ">=1.25.0"
+  },
+  "peerDependenciesMeta": {
+    "vxrn": {
+      "optional": true
+    }
+  },
+  "devDependencies": null,
+  "optionalDependencies": null
+}

package/src/build-initial.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+
+import { cmd } from './cmd'
+
+await cmd`bootstrap project workspace and build initial packages`.run(
+  async ({ $, fs, path }) => {
+    // use our own file because we know its takeout-like packages if it exists
+    const hasPackages = fs.existsSync(`./packages/scripts/src/build-initial.ts`)
+
+    // only run once
+    if (!fs.existsSync(`./node_modules/.bin/tko`)) {
+      if (hasPackages) {
+        symlinkBins()
+      }
+    }
+
+    // check if critical packages are built
+    if (hasPackages) {
+      if (!fs.existsSync(`./packages/helpers/dist`)) {
+        // build helpers first as other packages depend on it
+        await $`cd packages/helpers && bun run build`
+      }
+
+      // then build all other packages in parallel
+      await $`bun ./packages/run/src/run.ts build --no-root`
+    }
+
+    // show welcome message if not onboarded
+    checkAndShowWelcome()
+
+    function checkAndShowWelcome(cwd: string = process.cwd()): void {
+      try {
+        const packagePath = path.join(cwd, 'package.json')
+        const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf-8'))
+
+        if (pkg.takeout?.onboarded === false) {
+          console.info()
+          console.info(`
+████████╗ █████╗ ██╗  ██╗███████╗ ██████╗ ██╗   ██╗████████╗
+╚══██╔══╝██╔══██╗██║ ██╔╝██╔════╝██╔═══██╗██║   ██║╚══██╔══╝
+   ██║   ███████║█████╔╝ █████╗  ██║   ██║██║   ██║   ██║
+   ██║   ██╔══██║██╔═██╗ ██╔══╝  ██║   ██║██║   ██║   ██║
+   ██║   ██║  ██║██║  ██╗███████╗╚██████╔╝╚██████╔╝   ██║
+   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝ ╚═════╝  ╚═════╝    ╚═╝
+                        麵 碼 飯
+`)
+          console.info()
+          console.info('  welcome to takeout! 🥡')
+          console.info()
+          console.info('  run \x1b[32mbun onboard\x1b[0m to get things set up')
+          console.info()
+        }
+      } catch {
+        // silently fail if package.json doesn't exist or is malformed
+      }
+    }
+
+    function symlinkBins() {
+      // workaround for https://github.com/oven-sh/bun/issues/19782
+      const packagesWithCLI = [
+        { name: 'cli', cliFile: 'cli.mjs', alias: 'tko' },
+        { name: 'postgres', cliFile: 'cli.cjs' },
+      ]
+
+      const binDir = path.join(process.cwd(), 'node_modules', '.bin')
+
+      if (!fs.existsSync(binDir)) {
+        fs.mkdirSync(binDir, { recursive: true })
+      }
+
+      for (const pkg of packagesWithCLI) {
+        const binPath = path.join(binDir, pkg.name)
+        const sourcePath = path.join(process.cwd(), 'packages', pkg.name, pkg.cliFile)
+        symlinkTo(sourcePath, binPath)
+
+        if (pkg.alias) {
+          const aliasPath = path.join(binDir, pkg.alias)
+          symlinkTo(sourcePath, aliasPath)
+        }
+      }
+
+      function symlinkTo(source: string, target: string): void {
+        if (fs.existsSync(target)) {
+          console.info(`✓ Symlink already exists: ${target}`)
+          return
+        }
+
+        fs.symlinkSync(source, target)
+        console.info(`→ Created symlink: ${source} ⇢ ${target}`)
+      }
+    }
+  }
+)

package/src/clean.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env bun
+
+import { cmd } from './cmd'
+
+await cmd`clean build artifacts and temporary files`
+  .args('--full boolean --modules boolean --native boolean')
+  .run(async ({ args, $ }) => {
+    const full = args.full
+    const modules = full || args.modules
+    const native = full || args.native
+
+    await $`rm -rf dist types .tamagui .vite node_modules/.cache`
+
+    if (modules) {
+      console.info('removing all node_modules...')
+      await $`find . -name 'node_modules' -type d -prune -exec rm -rf {} +`
+    }
+
+    if (native) {
+      console.info('removing ios and android folders...')
+      await $`rm -rf ios android`
+    }
+
+    console.info('cleanup complete!')
+
+    if (!full) {
+      console.info('use --modules, --native, or --full for deeper cleaning')
+    }
+  })

package/src/cmd.ts

@@ -0,0 +1,105 @@
+type Prettify<T> = { [K in keyof T]: T[K] } & {}
+
+type CmdContext = {
+  $: typeof import('bun').$
+  colors: typeof import('picocolors')
+  prompt: typeof import('@clack/prompts')
+  run: typeof import('./helpers/run').run
+  fs: typeof import('node:fs')
+  path: typeof import('node:path')
+  os: typeof import('node:os')
+}
+
+type Args<S extends string> = import('./helpers/args').Args<S>
+
+type RunFn<S extends string> = (
+  fn: (ctx: Prettify<{ args: Args<S> } & CmdContext>) => Promise<void> | void
+) => Promise<void>
+
+let _interceptCmd: ((info: { description: string; args?: string }) => void) | undefined
+
+export function setInterceptCmd(
+  fn: ((info: { description: string; args?: string }) => void) | undefined
+) {
+  _interceptCmd = fn
+}
+
+function createCmd(description: string) {
+  let argsSpec: string | undefined
+  let envVars: Record<string, string> = {}
+
+  function makeRun<S extends string>(spec: S): RunFn<S> {
+    return async (fn) => {
+      if (_interceptCmd) {
+        _interceptCmd({ description, args: argsSpec })
+        return
+      }
+
+      const colors = (await import(`picocolors`)).default
+
+      if (process.argv.includes(`--help`) || process.argv.includes(`-h`)) {
+        console.info()
+        console.info(colors.bold(description))
+        if (argsSpec) {
+          console.info()
+          const flags = [...argsSpec.matchAll(/--?([a-z-]+)\s+(string|number|boolean)/gi)]
+          for (const [, flag, type] of flags) {
+            console.info(`  --${flag}  ${colors.dim(type!)}`)
+          }
+        }
+        console.info()
+        process.exit(0)
+      }
+
+      // apply env vars before running
+      for (const [key, value] of Object.entries(envVars)) {
+        process.env[key] = value
+      }
+
+      const [{ $ }, prompt, { run }, { args: parseArgs }, fs, path, os] =
+        await Promise.all([
+          import(`bun`),
+          import(`@clack/prompts`),
+          import(`./helpers/run`),
+          import(`./helpers/args`),
+          import(`node:fs`),
+          import(`node:path`),
+          import(`node:os`),
+        ])
+
+      const args = spec ? parseArgs(spec) : ({ rest: [] } as Args<S>)
+      await fn({ args, $, colors, prompt, run, fs, path, os } as Prettify<
+        { args: Args<S> } & CmdContext
+      >)
+    }
+  }
+
+  function makeChainable<S extends string>(spec: S) {
+    return {
+      env(vars: Record<string, string>) {
+        Object.assign(envVars, vars)
+        return this
+      },
+      run: makeRun(spec),
+    }
+  }
+
+  return {
+    env(vars: Record<string, string>) {
+      Object.assign(envVars, vars)
+      return this
+    },
+    args<const S extends string>(spec: S) {
+      argsSpec = spec
+      return makeChainable(spec)
+    },
+    run: makeRun(`` as ``),
+  }
+}
+
+export function cmd(description: string): ReturnType<typeof createCmd>
+export function cmd(strings: TemplateStringsArray): ReturnType<typeof createCmd>
+export function cmd(input: string | TemplateStringsArray) {
+  const description = typeof input === `string` ? input : input[0] || ``
+  return createCmd(description)
+}

package/src/dev-tunnel.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+
+import fs from 'node:fs'
+
+import { cmd } from './cmd'
+
+await cmd`set up cloudflare dev tunnel for local development`
+  .args('--port number')
+  .run(async ({ args, run, os, path }) => {
+    const { handleProcessExit } = await import('@o/run/helpers/handleProcessExit')
+
+    handleProcessExit()
+
+    const TUNNEL_CONFIG_DIR = path.join(os.homedir(), '.onechat-tunnel')
+    const TUNNEL_ID_FILE = path.join(TUNNEL_CONFIG_DIR, 'tunnel-id.txt')
+
+    async function ensureCloudflared(): Promise<boolean> {
+      try {
+        await run('cloudflared --version', { silent: true })
+        return true
+      } catch {
+        try {
+          await run('npm install -g cloudflared')
+          return true
+        } catch (error) {
+          console.error('Error installing cloudflared:', error)
+          return false
+        }
+      }
+    }
+
+    async function ensureAuthenticated(): Promise<boolean> {
+      const certPath = path.join(os.homedir(), '.cloudflared', 'cert.pem')
+      if (fs.existsSync(certPath)) {
+        return true
+      }
+
+      try {
+        await run('cloudflared tunnel login')
+        return true
+      } catch {
+        console.error('\n❌ Authentication failed')
+        return false
+      }
+    }
+
+    async function getOrCreateTunnel(): Promise<string | null> {
+      if (!fs.existsSync(TUNNEL_CONFIG_DIR)) {
+        fs.mkdirSync(TUNNEL_CONFIG_DIR, { recursive: true })
+      }
+
+      if (fs.existsSync(TUNNEL_ID_FILE)) {
+        const tunnelId = fs.readFileSync(TUNNEL_ID_FILE, 'utf-8').trim()
+        return tunnelId
+      }
+
+      const tunnelName = `onechat-dev-${process.env.USER || 'tunnel'}`
+
+      try {
+        const { stdout, stderr } = await run(`cloudflared tunnel create ${tunnelName}`, {
+          captureOutput: true,
+        })
+        const output = stdout + stderr
+
+        const match1 = output.match(/Created tunnel .+ with id ([a-f0-9-]+)/i)
+        const match2 = output.match(/Tunnel ([a-f0-9-]+) created/i)
+        const match3 = output.match(
+          /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/i
+        )
+
+        const tunnelId = match1?.[1] || match2?.[1] || match3?.[1]
+
+        if (tunnelId) {
+          fs.writeFileSync(TUNNEL_ID_FILE, tunnelId)
+          return tunnelId
+        }
+
+        console.error('Failed to extract tunnel ID from output')
+        console.error('Output was:', output)
+        return null
+      } catch (error: any) {
+        if (error.message?.includes('already exists')) {
+          try {
+            const { stdout } = await run(
+              `cloudflared tunnel list --name ${tunnelName} --output json`,
+              { captureOutput: true }
+            )
+            const tunnels = JSON.parse(stdout)
+            if (tunnels.length > 0) {
+              const tunnelId = tunnels[0].id
+              fs.writeFileSync(TUNNEL_ID_FILE, tunnelId)
+              return tunnelId
+            }
+          } catch (e) {
+            console.error('Failed to parse tunnel list:', e)
+          }
+        } else {
+          console.error('Failed to create tunnel:', error)
+        }
+        return null
+      }
+    }
+
+    const port = args.port ?? 8081
+
+    // ensure cloudflared is installed
+    const isInstalled = await ensureCloudflared()
+    if (!isInstalled) {
+      console.error('Failed to install cloudflared')
+      process.exit(1)
+    }
+
+    // ensure authenticated
+    const isAuthenticated = await ensureAuthenticated()
+    if (!isAuthenticated) {
+      console.error('Failed to authenticate with Cloudflare')
+      process.exit(1)
+    }
+
+    // get or create tunnel
+    const tunnelId = await getOrCreateTunnel()
+    if (!tunnelId) {
+      console.error('Failed to get or create tunnel')
+      process.exit(1)
+    }
+
+    // save the expected url immediately so it's available right away
+    const expectedUrl = `https://${tunnelId}.cfargotunnel.com`
+    fs.writeFileSync(path.join(TUNNEL_CONFIG_DIR, 'tunnel-url.txt'), expectedUrl)
+    console.info(`\n🌐 Tunnel URL: ${expectedUrl}`)
+
+    // get the public url in the background
+    setTimeout(async () => {
+      try {
+        const { stdout } = await run(
+          `cloudflared tunnel info ${tunnelId} --output json`,
+          {
+            captureOutput: true,
+            silent: true,
+          }
+        )
+
+        try {
+          const info = JSON.parse(stdout)
+          const hostname = info.hostname || `${tunnelId}.cfargotunnel.com`
+          fs.writeFileSync(
+            path.join(TUNNEL_CONFIG_DIR, 'tunnel-url.txt'),
+            `https://${hostname}`
+          )
+        } catch (e) {
+          // use fallback url already saved
+        }
+      } catch (e) {
+        // use fallback url already saved
+      }
+    }, 3000)
+
+    // run tunnel - managed by handleProcessExit
+    await run(`cloudflared tunnel run --url http://localhost:${port} ${tunnelId}`, {
+      detached: false,
+    })
+  })

package/src/ensure-port.ts

@@ -0,0 +1,79 @@
+#!/usr/bin/env bun
+
+import { cmd } from './cmd'
+
+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')
+
+    const port = args.rest[0]
+
+    if (!port) {
+      console.error('usage: bun tko ensure-port <port> [--auto-kill <prefix>]')
+      process.exit(1)
+    }
+
+    const portNum = Number.parseInt(port, 10)
+
+    if (Number.isNaN(portNum) || portNum < 1 || portNum > 65535) {
+      console.error(`invalid port: ${port}`)
+      process.exit(1)
+    }
+
+    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()
+
+        if (!output) return {}
+
+        const pid = Number.parseInt(output.split('\n')[0] || '', 10)
+        if (Number.isNaN(pid)) return {}
+
+        const ps = execSync(`ps -p ${pid} -o comm=`, {
+          encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'ignore'],
+        }).trim()
+
+        return { pid, command: ps }
+      } catch {
+        return {}
+      }
+    }
+
+    function killProcess(pid: number): boolean {
+      try {
+        execSync(`kill ${pid}`, { stdio: 'ignore' })
+        return true
+      } catch {
+        return false
+      }
+    }
+
+    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(`port ${portNum} in use by ${command || 'unknown'} (pid ${pid})`)
+      console.error(`run: kill ${pid}`)
+      process.exit(1)
+    }
+  })

package/src/ensure-tunnel.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env bun
+
+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/ensure-zero-sqlite.ts

@@ -0,0 +1,31 @@
+import { cmd } from './cmd'
+
+const SQLITE_NODE_PATH =
+  'node_modules/@rocicorp/zero-sqlite3/build/Release/better_sqlite3.node'
+
+await cmd`ensure zero-sqlite3 native module is built`.run(async ({ $, fs }) => {
+  if (fs.existsSync(SQLITE_NODE_PATH)) {
+    return
+  }
+
+  // bun trustedDependencies doesn't reliably run zero-sqlite3's install script,
+  // so build/fetch the native module ourselves. run the package's OWN install
+  // chain (`npm run install` = `prebuild-install || <binding exists?> ||
+  // node-gyp rebuild`), which prefers the PREBUILT binary and only source-builds
+  // as a last resort. @rocicorp/zero-sqlite3 >=1.1.2 is prebuilt-ONLY — its npm
+  // tarball omits generated headers (e.g. unicode_case_data.h), so a direct
+  // `npm run build-release` (node-gyp) fails; prebuild-install is the supported
+  // path. success is "the binding now exists" (the install chain can exit
+  // non-zero from a failed prebuild-install fallback even when an earlier step
+  // already produced the binding).
+  const result = await $`cd node_modules/@rocicorp/zero-sqlite3 && npm run install`
+    .quiet()
+    .nothrow()
+
+  if (!fs.existsSync(SQLITE_NODE_PATH)) {
+    console.error(
+      'zero-sqlite3 native module unavailable, will fall back to wasm:',
+      result.stderr.toString()
+    )
+  }
+})

package/src/env-pull.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+
+import fs from 'node:fs'
+
+import { cmd } from './cmd'
+
+await cmd`pull environment variables from SST production`.run(async ({ path }) => {
+  const { getEnvironment } = await import('./sst-get-environment')
+
+  const rootDir = process.cwd()
+
+  const envFilePath = path.join(rootDir, '.env.production')
+  if (fs.existsSync(envFilePath)) {
+    console.error(
+      '❌ Error: .env.production already exists. Please remove or rename it first.'
+    )
+    process.exit(1)
+  }
+
+  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)
+  }
+
+  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}`)
+      }
+    }
+
+    if (foundCount === 0) {
+      console.error(`❌ Error: None of the required environment variables were found.`)
+      process.exit(1)
+    }
+
+    fs.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)
+  }
+})