@take-out/scripts 0.0.52 → 0.0.58

package/package.json

@@ -1,17 +1,21 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.0.52",
+  "version": "0.0.58",
   "type": "module",
   "main": "./src/run.ts",
   "sideEffects": false,
   "exports": {
+    ".": {
+      "types": "./types/run.d.ts",
+      "default": "./src/run.ts"
+    },
     "./package.json": "./package.json",
     "./helpers/*": {
-      "types": "./src/helpers/*.ts",
+      "types": "./types/helpers/*.d.ts",
       "default": "./src/helpers/*.ts"
     },
     "./*": {
-      "types": "./src/*.ts",
+      "types": "./types/*.d.ts",
       "default": "./src/*.ts"
     }
   },
@@ -24,10 +28,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@take-out/helpers": "0.0.52",
-    "glob": "^11.0.0"
+    "@take-out/helpers": "0.0.58"
   },
   "devDependencies": {
-    "vxrn": "*"
+    "vxrn": "*1.4.0"
   }
 }

package/src/ensure-port.ts

@@ -6,20 +6,12 @@
  */
 
 import { execSync } from 'node:child_process'
-import { parseArgs } from 'node:util'
 
-const { values, positionals } = parseArgs({
-  args: process.argv.slice(2),
-  options: {
-    'auto-kill': {
-      type: 'string',
-      short: 'k',
-    },
-  },
-  allowPositionals: true,
-})
+import { args } from './helpers/args'
 
-const port = positionals[0]
+const { autoKill, _ } = args('--auto-kill string')
+
+const port = _[0]
 
 if (!port) {
   console.error('usage: bun tko ensure-port <port> [--auto-kill <prefix>]')
@@ -71,10 +63,8 @@ function killProcess(pid: number): boolean {
 const { pid, command } = getListeningProcess(portNum)
 
 if (pid) {
-  const autoKillPrefix = values['auto-kill']
-
   // check if we should auto-kill this process
-  if (autoKillPrefix && command?.startsWith(autoKillPrefix)) {
+  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

package/src/helpers/args.ts

@@ -0,0 +1,95 @@
+/**
+ * ultra simple typed arg parsing
+ *
+ * @example
+ * const { port, verbose, _ } = args`--port number --verbose boolean`
+ * // port: number | undefined
+ * // verbose: boolean
+ * // _: string[]
+ */
+
+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] } & {}
+
+type Args<S extends string> = Prettify<ParseFlags<S> & { _: 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-z-]+)\s+(string|number|boolean)/gi)
+
+  for (const [, flag, type] of matches) {
+    const camel = flag!.replace(/-([a-z])/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-z])/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/get-test-env.ts

@@ -1,3 +1,4 @@
+import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 
 import { loadEnv } from './env-load'
@@ -16,23 +17,44 @@ function getPortFromConnectionString(url: string | undefined): string | undefine
   }
 }
 
+// read a specific env var directly from .env.development file
+// (process.env may have production values if NODE_ENV=production)
+function getDevEnvVar(key: string): string | undefined {
+  try {
+    const envPath = join(process.cwd(), '.env.development')
+    const content = readFileSync(envPath, 'utf-8')
+    const regex = new RegExp(`^${key}=["']?([^"'\\n]+)["']?`, 'm')
+    const match = content.match(regex)
+    return match?.[1]
+  } catch {
+    return undefined
+  }
+}
+
+function getDevDbPort(): string | undefined {
+  const url = getDevEnvVar('ZERO_UPSTREAM_DB')
+  return url ? getPortFromConnectionString(url) : undefined
+}
+
 export async function getTestEnv() {
   const zeroVersion = getZeroVersion()
-  const devEnv = await loadEnv('development')
   const dockerHost = getDockerHost()
+  const devEnv = await loadEnv('development')
   const serverEnvFallback = await import(join(process.cwd(), 'src/server/env-server'))
 
   // determine db port from (in order of priority):
   // 1. DOCKER_DB_PORT env var
-  // 2. port from ZERO_UPSTREAM_DB in devEnv
+  // 2. port from ZERO_UPSTREAM_DB in .env.development file (read directly to avoid
+  //    bun auto-loading .env.production when NODE_ENV=production)
   // 3. default 5432
-  const dbPort =
-    process.env.DOCKER_DB_PORT ||
-    getPortFromConnectionString(devEnv.ZERO_UPSTREAM_DB as string) ||
-    '5432'
+  const dbPort = process.env.DOCKER_DB_PORT || getDevDbPort() || '5432'
 
   const dockerDbBase = `postgresql://user:password@127.0.0.1:${dbPort}`
 
+  // use dev BETTER_AUTH_SECRET for CI/staging to match local dev database keys
+  // (better-auth encrypts JWKS private keys with this secret, so it must match)
+  const devAuthSecret = getDevEnvVar('BETTER_AUTH_SECRET')
+
   return {
     ...serverEnvFallback,
     ...devEnv,
@@ -51,5 +73,7 @@ export async function getTestEnv() {
     CLOUDFLARE_R2_PUBLIC_URL: 'http://127.0.0.1:9200',
     CLOUDFLARE_R2_ACCESS_KEY: 'minio',
     CLOUDFLARE_R2_SECRET_KEY: 'minio_password',
+    // ensure auth secret matches dev db keys
+    ...(devAuthSecret && { BETTER_AUTH_SECRET: devAuthSecret }),
   }
 }

package/src/helpers/run.ts

@@ -84,7 +84,9 @@ export async function run(
   return runInternal()
 
   async function runInternal() {
-    if (!silent) {
+    // respect TKO_SILENT env var for quiet mode in watch scenarios
+    const effectiveSilent = silent || process.env.TKO_SILENT === '1'
+    if (!effectiveSilent) {
       console.info(`$ ${command}${cwd ? ` (in ${cwd})` : ``}`)
     }
 
@@ -117,7 +119,7 @@ export async function run(
       const coloredPrefix = prefix ? `${color}[${prefix}]${reset}` : ''
 
       const writeOutput = (text: string, isStderr: boolean) => {
-        if (!silent) {
+        if (!effectiveSilent) {
           const output = prefix ? `${coloredPrefix} ${text}` : text
           if (!prefix || !captureOutput) {
             const stream = isStderr ? process.stderr : process.stdout
@@ -130,7 +132,7 @@ export async function run(
         stream: ReadableStream<Uint8Array> | undefined,
         isStderr: boolean
       ): Promise<string> => {
-        if (silent && !captureOutput) {
+        if (effectiveSilent && !captureOutput) {
           return ''
         }
 

package/src/release.ts

@@ -127,7 +127,8 @@ async function main() {
 
       if (!skipTest) {
         await run(`bun lint`)
-        await run(`bun check`)
+        await run(`bun check:all`)
+        // only in packages
         // await run(`bun test`)
       }
     }
@@ -180,6 +181,8 @@ async function main() {
 
     if (!finish) {
       const tmpDir = `/tmp/one-publish`
+      // clean up from previous runs
+      await fs.remove(tmpDir)
       await ensureDir(tmpDir)
 
       await pMap(
@@ -216,6 +219,27 @@ async function main() {
 
           const filename = `${name.replace('/', '_')}-package.tmp.tgz`
           const absolutePath = `${tmpDir}/${filename}`
+
+          // swap exports.types from ./src/*.ts to ./types/*.d.ts for publishing
+          if (pkgJson.exports) {
+            const swapTypes = (obj: any) => {
+              for (const key in obj) {
+                const val = obj[key]
+                if (typeof val === 'object' && val !== null) {
+                  swapTypes(val)
+                } else if (
+                  key === 'types' &&
+                  typeof val === 'string' &&
+                  val.includes('/src/')
+                ) {
+                  obj[key] = val.replace('/src/', '/types/').replace('.ts', '.d.ts')
+                }
+              }
+            }
+            swapTypes(pkgJson.exports)
+            await writeJSON(pkgJsonPath, pkgJson, { spaces: 2 })
+          }
+
           await run(`npm pack --pack-destination ${tmpDir}`, {
             cwd: tmpPackageDir,
             silent: true,

package/src/run.ts

@@ -13,18 +13,22 @@ import { handleProcessExit } from '@take-out/scripts/helpers/handleProcessExit'
 import { getIsExiting } from './helpers/run'
 import { checkNodeVersion } from './node-version-check'
 
+// 256-color grays for subtle differentiation (232=darkest, 255=lightest)
 const colors = [
-  '\x1b[36m', // Cyan
-  '\x1b[35m', // Magenta
-  '\x1b[33m', // Yellow
-  '\x1b[32m', // Green
-  '\x1b[34m', // Blue
-  '\x1b[31m', // Red
-  '\x1b[90m', // Gray
+  '\x1b[38;5;245m', // medium gray
+  '\x1b[38;5;240m', // darker gray
+  '\x1b[38;5;250m', // lighter gray
+  '\x1b[38;5;243m', // medium-dark gray
+  '\x1b[38;5;248m', // medium-light gray
+  '\x1b[38;5;238m', // dark gray
+  '\x1b[38;5;252m', // light gray
 ]
 
 const reset = '\x1b[0m'
 
+// eslint-disable-next-line no-control-regex
+const ansiPattern = /\x1b\[[0-9;]*m/g
+
 // Verbose logging flag - set to false to reduce logs
 const verbose = false
 
@@ -40,11 +44,38 @@ const log = {
 const MAX_RESTARTS = 3
 
 // Separate command names from flags/arguments
+// Handles --flag=value and --flag value styles, excluding flag values from commands
 const args = process.argv.slice(2)
-const runCommands = args.filter((x) => !x.startsWith('--'))
+const ownFlags = ['--no-root', '--bun', '--watch', '--flags=last']
+const runCommands: string[] = []
+const forwardArgs: string[] = []
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i]!
+
+  if (arg.startsWith('--')) {
+    // handle flags
+    if (ownFlags.includes(arg) || arg.startsWith('--stdin=')) {
+      continue
+    }
+    forwardArgs.push(arg)
+    // if next arg exists and doesn't start with --, treat it as this flag's value
+    const nextArg = args[i + 1]
+    if (nextArg && !nextArg.startsWith('--')) {
+      forwardArgs.push(nextArg)
+      i++ // skip the value in next iteration
+    }
+  } else {
+    // non-flag arg is a command name
+    runCommands.push(arg)
+  }
+}
+
 const noRoot = args.includes('--no-root')
 const runBun = args.includes('--bun')
 const watch = args.includes('--watch') // just attempts to restart a failed process up to MAX_RESTARTS times
+// --flags=last forwards args only to last script, default forwards to all
+const flagsLast = args.includes('--flags=last')
 
 // parse --stdin=<script-name> to specify which script receives keyboard input
 // if not specified, defaults to the last script in the list
@@ -53,16 +84,6 @@ const stdinScript = stdinArg
   ? stdinArg.replace('--stdin=', '')
   : (runCommands[runCommands.length - 1] ?? null)
 
-// Collect additional flags and arguments to forward to sub-commands
-const forwardArgs = args.filter(
-  (arg) =>
-    arg.startsWith('--') &&
-    arg !== '--no-root' &&
-    arg !== '--bun' &&
-    arg !== '--watch' &&
-    !arg.startsWith('--stdin=')
-)
-
 // Get the list of scripts already being run by a parent process
 const parentRunningScripts = process.env.BUN_RUN_SCRIPTS
   ? process.env.BUN_RUN_SCRIPTS.split(',')
@@ -217,7 +238,8 @@ const runScript = async (
   name: string,
   cwd = '.',
   prefixLabel: string = name,
-  restarts = 0
+  restarts = 0,
+  extraArgs: string[] = []
 ) => {
   const colorIndex = processes.length % colors.length
   const color = colors[colorIndex]
@@ -226,7 +248,10 @@ const runScript = async (
   let stderrBuffer = ''
 
   // Construct command with arguments to forward
-  const runArgs = ['run', runBun ? '--bun' : '', name, ...forwardArgs].filter(Boolean)
+  // --silent suppresses bun's "$ command" output
+  const runArgs = ['run', '--silent', runBun ? '--bun' : '', name, ...extraArgs].filter(
+    Boolean
+  )
 
   // Log the exact command being run
   const commandDisplay = `bun ${runArgs.join(' ')}`
@@ -247,6 +272,8 @@ const runScript = async (
       FORCE_COLOR: '3',
       BUN_RUN_PARENT_SCRIPT: name,
       BUN_RUN_SCRIPTS: allRunningScripts,
+      // propagate silent mode to child scripts
+      TKO_SILENT: '1',
     } as any,
     cwd: resolve(cwd),
     detached: true,
@@ -261,6 +288,9 @@ const runScript = async (
     if (getIsExiting()) return // prevent output during cleanup
     const lines = data.toString().split('\n')
     for (const line of lines) {
+      // filter out bun's "$ command" echo lines in nested scripts
+      const stripped = line.replace(ansiPattern, '')
+      if (stripped.startsWith('$ ')) continue
       if (line) log.output(`${color}${prefixLabel}${reset} ${line}`)
     }
   })
@@ -272,6 +302,9 @@ const runScript = async (
     if (getIsExiting()) return // prevent output during cleanup
     const lines = dataStr.split('\n')
     for (const line of lines) {
+      // filter out bun's "$ command" echo lines in nested scripts
+      const stripped = line.replace(ansiPattern, '')
+      if (stripped.startsWith('$ ')) continue
       if (line) log.error(`${color}${prefixLabel}${reset} ${line}`)
     }
   })
@@ -290,35 +323,17 @@ const runScript = async (
       log.error(`${color}${prefixLabel}${reset} Process exited with code ${code}`)
 
       if (code === 1) {
-        // Print a nicer error message with red header
-        console.error(
-          '\n\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m'
-        )
         console.error('\x1b[31m❌ Run Failed\x1b[0m')
-        console.error(
-          '\x1b[31m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\x1b[0m'
-        )
         console.error(
           `\x1b[31mProcess "${prefixLabel}" failed with exit code ${code}\x1b[0m`
         )
 
-        // Show the original error output without prefixes
-        if (stderrBuffer.trim()) {
-          console.error('\n\x1b[31mError output:\x1b[0m')
-          console.error('\x1b[90m' + '─'.repeat(80) + '\x1b[0m')
-          const cleanedStderr = stderrBuffer
-          console.error(cleanedStderr)
-          console.error('\x1b[90m' + '─'.repeat(80) + '\x1b[0m')
-        }
-
-        console.error('')
-
         if (watch && restarts < MAX_RESTARTS) {
           const newRestarts = restarts + 1
           console.info(
             `Restarting process ${name} (${newRestarts}/${MAX_RESTARTS} times)`
           )
-          runScript(name, cwd, prefixLabel, newRestarts)
+          runScript(name, cwd, prefixLabel, newRestarts, extraArgs)
         } else {
           exit(1)
         }
@@ -337,11 +352,18 @@ async function main() {
 
   try {
     if (runCommands.length > 0) {
+      const lastScript = runCommands[runCommands.length - 1]
+
       // Root package.json scripts first, if not disabled
       if (!noRoot) {
-        const scriptPromises = runCommands
-          .filter((name) => !parentRunningScripts.includes(name))
-          .map((name) => runScript(name))
+        const filteredCommands = runCommands.filter(
+          (name) => !parentRunningScripts.includes(name)
+        )
+        const scriptPromises = filteredCommands.map((name) => {
+          // --flags=last: only forward args to last script
+          const args = !flagsLast || name === lastScript ? forwardArgs : []
+          return runScript(name, '.', name, 0, args)
+        })
 
         await Promise.all(scriptPromises)
       }
@@ -349,11 +371,14 @@ async function main() {
       const workspaceScriptMap = await mapWorkspacesToScripts(runCommands)
 
       for (const [workspace, { scripts, packageName }] of workspaceScriptMap.entries()) {
-        const workspaceScriptPromises = scripts
-          .filter((scriptName) => !parentRunningScripts.includes(scriptName))
-          .map((scriptName) =>
-            runScript(scriptName, workspace, `[${packageName}] [${scriptName}]`)
-          )
+        const filteredScripts = scripts.filter(
+          (scriptName) => !parentRunningScripts.includes(scriptName)
+        )
+        const workspaceScriptPromises = filteredScripts.map((scriptName) => {
+          // --flags=last: only forward args to last script
+          const args = !flagsLast || scriptName === lastScript ? forwardArgs : []
+          return runScript(scriptName, workspace, `${packageName} ${scriptName}`, 0, args)
+        })
 
         await Promise.all(workspaceScriptPromises)
       }

package/src/{update-deps.ts → up.ts}

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 
 /**
- * @description Update dependencies across workspace packages
+ * @description Upgrade packages by name (takeout, tamagui, one, zero, better-auth)
  */
 
 import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
@@ -14,7 +14,13 @@ const packagePatterns: string[] = []
 
 const args = process.argv.slice(2)
 
-for (const arg of args) {
+// check if first arg is a named upgrade set
+const rootDir = process.cwd()
+const rootPackageJson = JSON.parse(readFileSync(join(rootDir, 'package.json'), 'utf-8'))
+const upgradeSets: Record<string, string[]> = rootPackageJson.upgradeSets || {}
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i]
   if (arg.startsWith('--tag=')) {
     const tagValue = arg.split('=')[1]
     if (tagValue) {
@@ -26,21 +32,33 @@ for (const arg of args) {
   } else if (arg === '--tag') {
     console.error('Error: --tag option requires a value and must use = syntax.')
     console.error('Correct usage: --tag=canary')
-    console.error('Example: bun update-deps.ts --tag=canary react react-dom')
+    console.error('Example: bun tko up --tag=canary react react-dom')
     process.exit(1)
   } else if (arg === '--canary') {
     globalTag = 'canary'
   } else if (arg === '--rc') {
     globalTag = 'rc'
+  } else if (arg in upgradeSets) {
+    // expand named upgrade set to its patterns
+    packagePatterns.push(...upgradeSets[arg])
   } else {
     packagePatterns.push(arg)
   }
 }
 
 if (packagePatterns.length === 0) {
-  console.error('Please provide at least one package pattern to update.')
-  console.error('Example: bun update-deps.ts @vxrn/* vxrn')
-  console.error('Or with a tag: bun update-deps.ts --tag=canary @vxrn/* vxrn')
+  const setNames = Object.keys(upgradeSets)
+  if (setNames.length > 0) {
+    console.info('Usage: bun tko up <target|pattern> [options]')
+    console.info(`\nAvailable upgrade sets: ${setNames.join(', ')}`)
+    console.info('\nOr provide package patterns directly:')
+    console.info('  bun tko up @vxrn/* vxrn')
+    console.info('  bun tko up --tag=canary react react-dom')
+  } else {
+    console.error('Please provide at least one package pattern to update.')
+    console.error('Example: bun tko up @vxrn/* vxrn')
+    console.error('Or with a tag: bun tko up --tag=canary @vxrn/* vxrn')
+  }
   process.exit(1)
 }
 
@@ -58,7 +76,7 @@ function findPackageJsonFiles(dir: string): string[] {
     results.push(join(dir, 'package.json'))
   }
 
-  // Check if it's a monorepo with workspaces
+  // check if it's a monorepo with workspaces
   try {
     const packageJson = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf-8'))
     if (packageJson.workspaces) {
@@ -71,22 +89,60 @@ function findPackageJsonFiles(dir: string): string[] {
       }
 
       for (const workspace of workspacePaths) {
-        const workspaceDir = workspace.replace(/\/\*$/, '')
-        if (existsSync(join(dir, workspaceDir))) {
-          const subdirs = readdirSync(join(dir, workspaceDir), { withFileTypes: true })
-            .filter((dirent) => dirent.isDirectory())
-            .map((dirent) => join(dir, workspaceDir, dirent.name))
-
-          for (const subdir of subdirs) {
-            if (existsSync(join(subdir, 'package.json'))) {
-              results.push(join(subdir, 'package.json'))
+        // handle glob patterns like "packages/*", "code/**/*", "./code/ui/**/*"
+        const normalizedWorkspace = workspace.replace(/^\.\//, '')
+
+        if (normalizedWorkspace.includes('**')) {
+          // nested glob pattern - use glob to find all package.json files
+          const baseDir = normalizedWorkspace.split('**')[0].replace(/\/$/, '')
+          const basePath = join(dir, baseDir)
+
+          if (existsSync(basePath)) {
+            const findPackages = (searchDir: string) => {
+              try {
+                const entries = readdirSync(searchDir, { withFileTypes: true })
+                for (const entry of entries) {
+                  if (entry.isDirectory()) {
+                    const subPath = join(searchDir, entry.name)
+                    const pkgPath = join(subPath, 'package.json')
+                    if (existsSync(pkgPath)) {
+                      results.push(pkgPath)
+                    }
+                    // recurse into subdirectories
+                    findPackages(subPath)
+                  }
+                }
+              } catch (_e) {
+                // ignore permission errors
+              }
+            }
+            findPackages(basePath)
+          }
+        } else if (normalizedWorkspace.includes('*')) {
+          // simple glob pattern like "packages/*"
+          const workspaceDir = normalizedWorkspace.replace(/\/\*$/, '')
+          if (existsSync(join(dir, workspaceDir))) {
+            const subdirs = readdirSync(join(dir, workspaceDir), { withFileTypes: true })
+              .filter((dirent) => dirent.isDirectory())
+              .map((dirent) => join(dir, workspaceDir, dirent.name))
+
+            for (const subdir of subdirs) {
+              if (existsSync(join(subdir, 'package.json'))) {
+                results.push(join(subdir, 'package.json'))
+              }
             }
           }
+        } else {
+          // exact path like "code/tamagui.dev" or "./code/sandbox"
+          const pkgPath = join(dir, normalizedWorkspace, 'package.json')
+          if (existsSync(pkgPath)) {
+            results.push(pkgPath)
+          }
         }
       }
     }
   } catch (_error) {
-    // Ignore errors parsing package.json
+    // ignore errors parsing package.json
   }
 
   return results
@@ -258,7 +314,6 @@ function getWorkspaceName(packageJsonPath: string, rootDir: string): string {
 }
 
 async function main() {
-  const rootDir = process.cwd()
   const packageJsonFiles = findPackageJsonFiles(rootDir)
   console.info(`Found ${packageJsonFiles.length} package.json files`)
 
@@ -326,6 +381,12 @@ async function main() {
 
   await updatePackages(packagesByWorkspace, rootDir, packageJsonFiles)
 
+  // special handling for zero - update ZERO_VERSION in .env
+  if (packagePatterns.includes('@rocicorp/zero')) {
+    console.info('\n🔄 Updating local env for Zero...')
+    await $`bun tko run update-local-env`
+  }
+
   console.info('\n🎉 Dependency update complete!')
 }
 

package/src/check-circular-deps.ts

@@ -1,129 +0,0 @@
-#!/usr/bin/env bun
-
-import { basename } from 'node:path'
-
-import { $ } from 'bun'
-import { globSync } from 'glob'
-
-const projectRoot = process.cwd()
-
-// parse --ignore flag
-const args = process.argv.slice(2)
-const ignoreIndex = args.indexOf('--ignore')
-const ignoredFiles: string[] = []
-
-if (ignoreIndex !== -1 && args[ignoreIndex + 1]) {
-  // split comma-separated files
-  const ignoreArg = args[ignoreIndex + 1]
-  if (ignoreArg) {
-    const ignoreList = ignoreArg.split(',')
-    ignoredFiles.push(...ignoreList.map((f) => f.trim()))
-  }
-}
-
-// glob all tsx files in app directory
-const appFiles = globSync('app/**/*.tsx', {
-  cwd: projectRoot,
-  absolute: true,
-})
-
-// glob all tsx files in src directory
-const srcFiles = globSync('src/**/*.tsx', {
-  cwd: projectRoot,
-  absolute: true,
-})
-
-// combine all files
-const allFiles = [...appFiles, ...srcFiles]
-
-if (allFiles.length === 0) {
-  console.error('No tsx files found')
-  process.exit(1)
-}
-
-// build the command with all -r flags
-const commandArgs = [
-  'bunx',
-  '@glideapps/ts-helper',
-  '-c', // check circular dependencies
-  '-p',
-  projectRoot,
-  ...allFiles.flatMap((file) => ['-r', file]),
-]
-
-console.info(`Checking circular dependencies for ${allFiles.length} files...`)
-
-try {
-  // run the command and capture output
-  await $`${commandArgs}`.quiet()
-  console.info('✅ No circular dependencies found')
-} catch (error: any) {
-  // parse the output to check for cycles
-  const output = error.stderr?.toString() || error.stdout?.toString() || ''
-
-  // check if this is a tool crash (assertion error) rather than actual cycle detection
-  if (output.includes('Assertion failed') || output.includes('at panic')) {
-    const nodeVersion = process.versions.node
-    const majorVersion = parseInt(nodeVersion.split('.')[0] || '0', 10)
-    if (majorVersion >= 24) {
-      console.warn(`⚠️ @glideapps/ts-helper crashes on Node.js ${nodeVersion}`)
-      console.warn('   skipping locally - CI uses Node 20 where this check runs properly')
-      process.exit(0)
-    }
-    // unknown crash on older node, fail
-    console.error(output)
-    console.error('❌ Circular dependency check crashed unexpectedly')
-    process.exit(1)
-  }
-
-  // parse cycle arrays from output
-  const cycleRegex = /\[([^\]]+)\]/g
-  const cycles: string[][] = []
-  let match
-
-  while ((match = cycleRegex.exec(output)) !== null) {
-    // parse the cycle array
-    const cycleStr = match[1]
-    if (cycleStr) {
-      const files = cycleStr.split(',').map((f) => f.trim().replace(/"/g, ''))
-      cycles.push(files)
-    }
-  }
-
-  // filter out cycles that contain ignored files
-  const remainingCycles = cycles.filter((cycle) => {
-    const containsIgnored = cycle.some((file) =>
-      ignoredFiles.some((ignored) => basename(file) === ignored || file.includes(ignored))
-    )
-    return !containsIgnored
-  })
-
-  if (remainingCycles.length > 0) {
-    // reconstruct output with filtered cycles
-    console.info(
-      output
-        .split('\n')
-        .filter((line: string) => !line.startsWith('['))
-        .join('\n')
-    )
-    console.info(`Found ${remainingCycles.length} dependency cycles`)
-    remainingCycles.forEach((cycle) => {
-      console.info(JSON.stringify(cycle))
-    })
-    console.error('❌ Circular dependencies detected')
-    process.exit(1)
-  } else if (cycles.length > 0) {
-    // all cycles were ignored
-    console.info(
-      `✅ Found ${cycles.length} circular dependencies but all contain ignored files`
-    )
-    if (ignoredFiles.length > 0) {
-      console.info(`   Ignored files: ${ignoredFiles.join(', ')}`)
-    }
-  } else {
-    // no cycles found, but command failed for another reason
-    console.error(output)
-    console.error('❌ Error running circular dependency check')
-    process.exit(1)
-  }
-}