@take-out/scripts 0.0.92 → 0.0.94

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.0.92",
+  "version": "0.0.94",
   "type": "module",
   "main": "./src/run.ts",
   "sideEffects": false,
@@ -28,7 +28,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@take-out/helpers": "0.0.79"
+    "@clack/prompts": "^0.8.2",
+    "@take-out/helpers": "0.0.94",
+    "picocolors": "^1.1.1"
   },
   "peerDependencies": {
     "vxrn": "^1.4.15"

package/src/build-initial.ts

@@ -1,51 +1,47 @@
 #!/usr/bin/env bun
 
-/**
- * @description Bootstrap project workspace and build initial packages. This is
- * mostly important for Takeout starter kit itself.
- */
+import { cmd } from './cmd'
 
-import { existsSync, mkdirSync, readFileSync, symlinkSync } from 'node:fs'
-import { exists } from 'node:fs/promises'
-import { join } from 'node:path'
+await cmd`bootstrap project workspace and build initial packages`.run(
+  async ({ $, fs, path }) => {
+    const { existsSync, mkdirSync, readFileSync, symlinkSync } = await import('node:fs')
+    const { exists } = fs
 
-import { $ } from 'bun'
+    const hasPackages = await exists(`./packages`)
 
-const hasPackages = await exists(`./packages`)
-
-// only run once:
-if (!(await exists(`./node_modules/.bin/tko`))) {
-  if (hasPackages) {
-    symlinkBins()
-  }
-}
+    // only run once
+    if (!(await exists(`./node_modules/.bin/tko`))) {
+      if (hasPackages) {
+        symlinkBins()
+      }
+    }
 
-// check if critical packages are built - both helpers and cli are needed for tko to work
-if (hasPackages) {
-  const needsBuild =
-    !(await exists(`./packages/helpers/dist`)) ||
-    !(await exists(`./packages/cli/dist/esm`))
+    // check if critical packages are built
+    if (hasPackages) {
+      const needsBuild =
+        !(await exists(`./packages/helpers/dist`)) ||
+        !(await exists(`./packages/cli/dist/esm`))
 
-  if (needsBuild) {
-    // build helpers first as other packages depend on it
-    await $`cd packages/helpers && bun run build`
+      if (needsBuild) {
+        // 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/scripts/src/run.ts build --no-root`
-  }
-}
+        // then build all other packages in parallel
+        await $`bun ./packages/scripts/src/run.ts build --no-root`
+      }
+    }
 
-// show welcome message if not onboarded
-checkAndShowWelcome()
+    // show welcome message if not onboarded
+    checkAndShowWelcome()
 
-function checkAndShowWelcome(cwd: string = process.cwd()): void {
-  try {
-    const packagePath = join(cwd, 'package.json')
-    const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'))
+    function checkAndShowWelcome(cwd: string = process.cwd()): void {
+      try {
+        const packagePath = path.join(cwd, 'package.json')
+        const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'))
 
-    if (pkg.takeout?.onboarded === false) {
-      console.info()
-      console.info(`
+        if (pkg.takeout?.onboarded === false) {
+          console.info()
+          console.info(`
 ████████╗ █████╗ ██╗  ██╗███████╗ ██████╗ ██╗   ██╗████████╗
 ╚══██╔══╝██╔══██╗██║ ██╔╝██╔════╝██╔═══██╗██║   ██║╚══██╔══╝
    ██║   ███████║█████╔╝ █████╗  ██║   ██║██║   ██║   ██║
@@ -54,51 +50,50 @@ function checkAndShowWelcome(cwd: string = process.cwd()): void {
    ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝ ╚═════╝  ╚═════╝    ╚═╝
                         麵 碼 飯
 `)
-      console.info()
-      console.info('  welcome to takeout! 🥡')
-      console.info()
-      console.info('  run \x1b[32mbun onboard\x1b[0m to get things set up')
-      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
+      }
     }
-  } catch {
-    // silently fail if package.json doesn't exist or is malformed
-  }
-}
-
-function symlinkBins() {
-  // workaround for https://github.com/oven-sh/bun/issues/19782
-  // bun doesn't create symlinks for workspace packages properly
-  const packagesWithCLI = [
-    { name: 'cli', cliFile: 'cli.mjs', alias: 'tko' },
-    { name: 'postgres', cliFile: 'cli.cjs' },
-  ]
-
-  const binDir = join(process.cwd(), 'node_modules', '.bin')
 
-  if (!existsSync(binDir)) {
-    mkdirSync(binDir, { recursive: true })
-  }
-
-  for (const pkg of packagesWithCLI) {
-    const binPath = join(binDir, pkg.name)
-    const sourcePath = join(process.cwd(), 'packages', pkg.name, pkg.cliFile)
-    symlinkTo(sourcePath, binPath)
-
-    if (pkg.alias) {
-      const aliasPath = join(binDir, pkg.alias)
-      // create alias symlink pointing to the source
-      symlinkTo(sourcePath, aliasPath)
+    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 (!existsSync(binDir)) {
+        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 (existsSync(target)) {
+          console.info(`✓ Symlink already exists: ${target}`)
+          return
+        }
+
+        symlinkSync(source, target)
+        console.info(`→ Created symlink: ${source} ⇢ ${target}`)
+      }
     }
   }
-
-  // helper function to create symlink with existence check
-  function symlinkTo(source: string, target: string): void {
-    if (existsSync(target)) {
-      console.info(`✓ Symlink already exists: ${target}`)
-      return
-    }
-
-    symlinkSync(source, target)
-    console.info(`→ Created symlink: ${source} ⇢ ${target}`)
-  }
-}
+)

package/src/clean.ts

@@ -1,29 +1,29 @@
 #!/usr/bin/env bun
 
-/**
- * @description Clean build artifacts and temporary files
- */
+import { cmd } from './cmd'
 
-import { $ } from 'bun'
+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
 
-const full = process.argv.includes('--full')
-const modules = full || process.argv.includes('--modules')
-const native = full || process.argv.includes('--native')
+    await $`rm -rf dist types .tamagui .vite node_modules/.cache`
 
-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 (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`
+    }
 
-if (native) {
-  console.info('removing ios and android folders...')
-  await $`rm -rf ios android`
-}
+    console.info('cleanup complete!')
 
-console.info('cleanup complete!')
-
-if (!full) {
-  console.info('use --modules, --native, or --full for deeper cleaning')
-}
+    if (!full) {
+      console.info('use --modules, --native, or --full for deeper cleaning')
+    }
+  })

package/src/cmd.ts

@@ -0,0 +1,82 @@
+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/promises')
+  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
+
+  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)
+      }
+
+      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/promises`),
+        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
+      >)
+    }
+  }
+
+  return {
+    args<const S extends string>(spec: S) {
+      argsSpec = spec
+      return { run: makeRun(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

@@ -1,179 +1,158 @@
 #!/usr/bin/env bun
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-
-import { handleProcessExit } from './helpers/handleProcessExit'
-import { run } from './helpers/run'
-
-handleProcessExit()
-
-const TUNNEL_CONFIG_DIR = join(homedir(), '.onechat-tunnel')
-const TUNNEL_ID_FILE = join(TUNNEL_CONFIG_DIR, 'tunnel-id.txt')
-
-async function ensureCloudflared(): Promise<boolean> {
-  try {
-    // check if cloudflared is installed
-    await run('cloudflared --version', { silent: true })
-    return true
-  } catch {
-    // install cloudflared using npm
-    try {
-      await run('npm install -g cloudflared')
-      return true
-    } catch (error) {
-      console.error('Error installing cloudflared:', error)
-      return false
-    }
-  }
-}
-
-async function ensureAuthenticated(): Promise<boolean> {
-  // check if we have credentials
-  const certPath = join(homedir(), '.cloudflared', 'cert.pem')
-  if (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> {
-  // create config directory if it doesn't exist
-  if (!existsSync(TUNNEL_CONFIG_DIR)) {
-    mkdirSync(TUNNEL_CONFIG_DIR, { recursive: true })
-  }
-
-  // check if we have a saved tunnel ID
-  if (existsSync(TUNNEL_ID_FILE)) {
-    const tunnelId = readFileSync(TUNNEL_ID_FILE, 'utf-8').trim()
-    return tunnelId
-  }
-
-  // create a new tunnel with a stable name
-  const tunnelName = `onechat-dev-${process.env.USER || 'tunnel'}`
-
-  try {
-    const { stdout, stderr } = await run(`cloudflared tunnel create ${tunnelName}`, {
-      captureOutput: true,
-    })
-    const output = stdout + stderr
+import { cmd } from './cmd'
+
+await cmd`set up cloudflare dev tunnel for local development`
+  .args('--port number')
+  .run(async ({ args, run, os, path }) => {
+    const { existsSync, mkdirSync, readFileSync, writeFileSync } = await import('node:fs')
+    const { handleProcessExit } = await import('./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')
 
-    // extract tunnel ID from output - try multiple patterns
-    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
-    )
+    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
+        }
+      }
+    }
 
-    const tunnelId = match1?.[1] || match2?.[1] || match3?.[1]
+    async function ensureAuthenticated(): Promise<boolean> {
+      const certPath = path.join(os.homedir(), '.cloudflared', 'cert.pem')
+      if (existsSync(certPath)) {
+        return true
+      }
 
-    if (tunnelId) {
-      writeFileSync(TUNNEL_ID_FILE, tunnelId)
-      return tunnelId
+      try {
+        await run('cloudflared tunnel login')
+        return true
+      } catch {
+        console.error('\n❌ Authentication failed')
+        return false
+      }
     }
 
-    console.error('Failed to extract tunnel ID from output')
-    console.error('Output was:', output)
-    return null
-  } catch (error: any) {
-    // check if tunnel already exists
-    if (error.message?.includes('already exists')) {
+    async function getOrCreateTunnel(): Promise<string | null> {
+      if (!existsSync(TUNNEL_CONFIG_DIR)) {
+        mkdirSync(TUNNEL_CONFIG_DIR, { recursive: true })
+      }
+
+      if (existsSync(TUNNEL_ID_FILE)) {
+        const tunnelId = readFileSync(TUNNEL_ID_FILE, 'utf-8').trim()
+        return tunnelId
+      }
+
+      const tunnelName = `onechat-dev-${process.env.USER || 'tunnel'}`
+
       try {
-        const { stdout } = await run(
-          `cloudflared tunnel list --name ${tunnelName} --output json`,
-          { captureOutput: true }
+        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 tunnels = JSON.parse(stdout)
-        if (tunnels.length > 0) {
-          const tunnelId = tunnels[0].id
+
+        const tunnelId = match1?.[1] || match2?.[1] || match3?.[1]
+
+        if (tunnelId) {
           writeFileSync(TUNNEL_ID_FILE, tunnelId)
           return tunnelId
         }
-      } catch (e) {
-        console.error('Failed to parse tunnel list:', e)
+
+        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
+              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
       }
-    } else {
-      console.error('Failed to create tunnel:', error)
     }
-    return null
-  }
-}
-
-async function runTunnel(port: number = 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`
-  writeFileSync(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,
-      })
 
+    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`
+    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 info = JSON.parse(stdout)
-        const hostname = info.hostname || `${tunnelId}.cfargotunnel.com`
-        writeFileSync(join(TUNNEL_CONFIG_DIR, 'tunnel-url.txt'), `https://${hostname}`)
+        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`
+          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
+        // use fallback url already saved
       }
-    } catch (e) {
-      // use fallback URL already saved
-    }
-  }, 3000)
+    }, 3000)
 
-  // run tunnel in detached mode so it keeps running and gets managed by handleProcessExit
-  await run(`cloudflared tunnel run --url http://localhost:${port} ${tunnelId}`, {
-    detached: false,
+    // run tunnel - managed by handleProcessExit
+    await run(`cloudflared tunnel run --url http://localhost:${port} ${tunnelId}`, {
+      detached: false,
+    })
   })
-}
-
-// Parse command line arguments
-const args = process.argv.slice(2)
-let port = 8081
-
-for (let i = 0; i < args.length; i++) {
-  if (args[i] === '--port' && args[i + 1]) {
-    const portArg = args[i + 1]
-    if (portArg) {
-      const parsedPort = parseInt(portArg, 10)
-      if (!Number.isNaN(parsedPort)) {
-        port = parsedPort
-      }
-    }
-  }
-}
-
-runTunnel(port)