@take-out/scripts 0.0.97 → 0.0.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.0.97",
+  "version": "0.0.99",
   "type": "module",
   "main": "./src/run.ts",
   "sideEffects": false,
@@ -29,7 +29,7 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.8.2",
-    "@take-out/helpers": "0.0.97",
+    "@take-out/helpers": "0.0.99",
     "picocolors": "^1.1.1"
   },
   "peerDependencies": {

package/src/build-initial.ts

@@ -4,13 +4,10 @@ import { cmd } from './cmd'
 
 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
-
-    const hasPackages = await exists(`./packages`)
+    const hasPackages = fs.existsSync(`./packages`)
 
     // only run once
-    if (!(await exists(`./node_modules/.bin/tko`))) {
+    if (!fs.existsSync(`./node_modules/.bin/tko`)) {
       if (hasPackages) {
         symlinkBins()
       }
@@ -19,8 +16,8 @@ await cmd`bootstrap project workspace and build initial packages`.run(
     // check if critical packages are built
     if (hasPackages) {
       const needsBuild =
-        !(await exists(`./packages/helpers/dist`)) ||
-        !(await exists(`./packages/cli/dist/esm`))
+        !fs.existsSync(`./packages/helpers/dist`) ||
+        !fs.existsSync(`./packages/cli/dist/esm`)
 
       if (needsBuild) {
         // build helpers first as other packages depend on it
@@ -37,7 +34,7 @@ await cmd`bootstrap project workspace and build initial packages`.run(
     function checkAndShowWelcome(cwd: string = process.cwd()): void {
       try {
         const packagePath = path.join(cwd, 'package.json')
-        const pkg = JSON.parse(readFileSync(packagePath, 'utf-8'))
+        const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf-8'))
 
         if (pkg.takeout?.onboarded === false) {
           console.info()
@@ -70,8 +67,8 @@ await cmd`bootstrap project workspace and build initial packages`.run(
 
       const binDir = path.join(process.cwd(), 'node_modules', '.bin')
 
-      if (!existsSync(binDir)) {
-        mkdirSync(binDir, { recursive: true })
+      if (!fs.existsSync(binDir)) {
+        fs.mkdirSync(binDir, { recursive: true })
       }
 
       for (const pkg of packagesWithCLI) {
@@ -86,12 +83,12 @@ await cmd`bootstrap project workspace and build initial packages`.run(
       }
 
       function symlinkTo(source: string, target: string): void {
-        if (existsSync(target)) {
+        if (fs.existsSync(target)) {
           console.info(`✓ Symlink already exists: ${target}`)
           return
         }
 
-        symlinkSync(source, target)
+        fs.symlinkSync(source, target)
         console.info(`→ Created symlink: ${source} ⇢ ${target}`)
       }
     }

package/src/cmd.ts

@@ -5,7 +5,7 @@ type CmdContext = {
   colors: typeof import('picocolors')
   prompt: typeof import('@clack/prompts')
   run: typeof import('./helpers/run').run
-  fs: typeof import('node:fs/promises')
+  fs: typeof import('node:fs')
   path: typeof import('node:path')
   os: typeof import('node:os')
 }
@@ -56,7 +56,7 @@ function createCmd(description: string) {
           import(`@clack/prompts`),
           import(`./helpers/run`),
           import(`./helpers/args`),
-          import(`node:fs/promises`),
+          import(`node:fs`),
           import(`node:path`),
           import(`node:os`),
         ])

package/src/dev-tunnel.ts

@@ -1,11 +1,12 @@
 #!/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 { existsSync, mkdirSync, readFileSync, writeFileSync } = await import('node:fs')
     const { handleProcessExit } = await import('./helpers/handleProcessExit')
 
     handleProcessExit()
@@ -30,7 +31,7 @@ await cmd`set up cloudflare dev tunnel for local development`
 
     async function ensureAuthenticated(): Promise<boolean> {
       const certPath = path.join(os.homedir(), '.cloudflared', 'cert.pem')
-      if (existsSync(certPath)) {
+      if (fs.existsSync(certPath)) {
         return true
       }
 
@@ -44,12 +45,12 @@ await cmd`set up cloudflare dev tunnel for local development`
     }
 
     async function getOrCreateTunnel(): Promise<string | null> {
-      if (!existsSync(TUNNEL_CONFIG_DIR)) {
-        mkdirSync(TUNNEL_CONFIG_DIR, { recursive: true })
+      if (!fs.existsSync(TUNNEL_CONFIG_DIR)) {
+        fs.mkdirSync(TUNNEL_CONFIG_DIR, { recursive: true })
       }
 
-      if (existsSync(TUNNEL_ID_FILE)) {
-        const tunnelId = readFileSync(TUNNEL_ID_FILE, 'utf-8').trim()
+      if (fs.existsSync(TUNNEL_ID_FILE)) {
+        const tunnelId = fs.readFileSync(TUNNEL_ID_FILE, 'utf-8').trim()
         return tunnelId
       }
 
@@ -70,7 +71,7 @@ await cmd`set up cloudflare dev tunnel for local development`
         const tunnelId = match1?.[1] || match2?.[1] || match3?.[1]
 
         if (tunnelId) {
-          writeFileSync(TUNNEL_ID_FILE, tunnelId)
+          fs.writeFileSync(TUNNEL_ID_FILE, tunnelId)
           return tunnelId
         }
 
@@ -87,7 +88,7 @@ await cmd`set up cloudflare dev tunnel for local development`
             const tunnels = JSON.parse(stdout)
             if (tunnels.length > 0) {
               const tunnelId = tunnels[0].id
-              writeFileSync(TUNNEL_ID_FILE, tunnelId)
+              fs.writeFileSync(TUNNEL_ID_FILE, tunnelId)
               return tunnelId
             }
           } catch (e) {
@@ -125,7 +126,7 @@ await cmd`set up cloudflare dev tunnel for local development`
 
     // 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)
+    fs.writeFileSync(path.join(TUNNEL_CONFIG_DIR, 'tunnel-url.txt'), expectedUrl)
     console.info(`\n🌐 Tunnel URL: ${expectedUrl}`)
 
     // get the public url in the background
@@ -142,7 +143,7 @@ await cmd`set up cloudflare dev tunnel for local development`
         try {
           const info = JSON.parse(stdout)
           const hostname = info.hostname || `${tunnelId}.cfargotunnel.com`
-          writeFileSync(
+          fs.writeFileSync(
             path.join(TUNNEL_CONFIG_DIR, 'tunnel-url.txt'),
             `https://${hostname}`
           )

package/src/env-pull.ts

@@ -1,15 +1,16 @@
 #!/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 { 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)) {
+  if (fs.existsSync(envFilePath)) {
     console.error(
       '❌ Error: .env.production already exists. Please remove or rename it first.'
     )
@@ -45,7 +46,7 @@ await cmd`pull environment variables from SST production`.run(async ({ path }) =
       process.exit(1)
     }
 
-    writeFileSync(envFilePath, envFileContent)
+    fs.writeFileSync(envFilePath, envFileContent)
 
     console.info(
       `✅ Success! ${foundCount} environment variables written to .env.production`

package/src/env-update.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env bun
 
+import fs from 'node:fs'
+
 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 packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'))
     const envVars = packageJson.env as Record<string, boolean | string>
 
     if (!envVars || Array.isArray(envVars) || typeof envVars !== 'object') {
@@ -36,7 +36,7 @@ await cmd`sync environment variables from package.json to CI and server configs`
 
     function updateDeployYml() {
       const deployYmlPath = '.github/workflows/ci.yml'
-      let deployYml = readFileSync(deployYmlPath, 'utf-8')
+      let deployYml = fs.readFileSync(deployYmlPath, 'utf-8')
 
       if (!deployYml.includes(yamlStartMarker) || !deployYml.includes(yamlEndMarker)) {
         throw new Error(`Markers not found in ${deployYmlPath}`)
@@ -49,7 +49,7 @@ await cmd`sync environment variables from package.json to CI and server configs`
 
       const newDeployYml = replaceYamlSection(deployYml, envSection, { indent })
 
-      writeFileSync(deployYmlPath, newDeployYml, 'utf-8')
+      fs.writeFileSync(deployYmlPath, newDeployYml, 'utf-8')
       console.info('✅ Updated Github workflow')
     }
 
@@ -60,7 +60,7 @@ await cmd`sync environment variables from package.json to CI and server configs`
 
       for (const p of candidates) {
         try {
-          envServer = readFileSync(p, 'utf-8')
+          envServer = fs.readFileSync(p, 'utf-8')
           envServerPath = p
           break
         } catch {}
@@ -75,10 +75,13 @@ await cmd`sync environment variables from package.json to CI and server configs`
       }
 
       const envExports = Object.entries(envVars)
-        .map(
-          ([key, value]) =>
-            `export const ${key} = ensureEnv('${key}'${typeof value === 'string' ? `, ${JSON.stringify(value)}` : ''})`
-        )
+        .map(([key, value]) => {
+          // $dep: values have no compile-time default — resolved into .env at runtime
+          if (typeof value === 'string' && value.startsWith('$dep:')) {
+            return `export const ${key} = ensureEnv('${key}')`
+          }
+          return `export const ${key} = ensureEnv('${key}'${typeof value === 'string' ? `, ${JSON.stringify(value)}` : ''})`
+        })
         .join('\n')
 
       const newEnvServer = envServer.replace(
@@ -86,7 +89,7 @@ await cmd`sync environment variables from package.json to CI and server configs`
         `${jsStartMarker}\n${envExports}\n${jsEndMarker}`
       )
 
-      writeFileSync(envServerPath, newEnvServer, 'utf-8')
+      fs.writeFileSync(envServerPath, newEnvServer, 'utf-8')
       console.info('✅ Updated server env')
     }
 
@@ -95,7 +98,7 @@ await cmd`sync environment variables from package.json to CI and server configs`
 
       let dockerCompose = ''
       try {
-        dockerCompose = readFileSync(dockerComposePath, 'utf-8')
+        dockerCompose = fs.readFileSync(dockerComposePath, 'utf-8')
       } catch (_error) {
         // file doesn't exist, skip
         return
@@ -128,7 +131,7 @@ await cmd`sync environment variables from package.json to CI and server configs`
 
       const newDockerCompose = replaceYamlSection(dockerCompose, envLines, { indent })
 
-      writeFileSync(dockerComposePath, newDockerCompose, 'utf-8')
+      fs.writeFileSync(dockerComposePath, newDockerCompose, 'utf-8')
       console.info('✅ Updated docker-compose.yml')
     }
 

package/src/helpers/env-load.ts

@@ -1,4 +1,4 @@
-import { existsSync } from 'node:fs'
+import fs from 'node:fs'
 import { join } from 'node:path'
 
 import { loadEnv as vxrnLoadEnv } from 'vxrn/loadEnv'
@@ -31,7 +31,7 @@ function resolveEnvServerPath(): string {
   const candidates = ['src/constants/env-server.ts', 'src/server/env-server.ts']
   for (const candidate of candidates) {
     const full = join(process.cwd(), candidate)
-    if (existsSync(full)) {
+    if (fs.existsSync(full)) {
       return full
     }
   }

package/src/helpers/get-test-env.ts

@@ -1,18 +1,16 @@
-import { existsSync } from 'node:fs'
+import fs from 'node:fs'
 import { join } from 'node:path'
 
 import { loadEnv } from './env-load'
 import { getDockerHost } from './get-docker-host'
-import { getZeroVersion } from './zero-get-version'
 
 export async function getTestEnv() {
-  const zeroVersion = getZeroVersion()
   const dockerHost = getDockerHost()
   const devEnv = await loadEnv('development')
   const envPath =
     ['src/constants/env-server', 'src/server/env-server']
       .map((p) => join(process.cwd(), p))
-      .find((p) => existsSync(p + '.ts')) ||
+      .find((p) => fs.existsSync(p + '.ts')) ||
     join(process.cwd(), 'src/constants/env-server')
   const serverEnvFallback = await import(envPath)
 
@@ -31,7 +29,6 @@ export async function getTestEnv() {
       ZERO_LOG_LEVEL: 'warn',
     }),
     DO_NOT_TRACK: '1',
-    ZERO_VERSION: zeroVersion,
     ZERO_MUTATE_URL: `http://${dockerHost}:${appPort}/api/zero/push`,
     ZERO_QUERY_URL: `http://${dockerHost}:${appPort}/api/zero/pull`,
     ZERO_UPSTREAM_DB: `${dockerDbBase}/postgres`,

package/src/helpers/multipass.ts

@@ -1,4 +1,4 @@
-import { writeFileSync } from 'node:fs'
+import fs from 'node:fs'
 
 import { sleep } from '@take-out/helpers'
 
@@ -66,7 +66,7 @@ packages:
 `
 
   const cloudInitPath = `${process.cwd()}/.cloud-init.yml`
-  writeFileSync(cloudInitPath, cloudInit)
+  fs.writeFileSync(cloudInitPath, cloudInit)
 
   try {
     await run(

package/src/helpers/process-compose-env.ts

@@ -1,4 +1,4 @@
-import { readFileSync, writeFileSync } from 'node:fs'
+import fs from 'node:fs'
 
 // make values safe for yaml map syntax (KEY: value)
 // handles multi-line values, special chars that break yaml parsing
@@ -30,7 +30,7 @@ export function processComposeEnv(
   outputFile: string,
   envVars: Record<string, string | undefined>
 ): void {
-  let content = readFileSync(composeFile, 'utf-8')
+  let content = fs.readFileSync(composeFile, 'utf-8')
 
   // replace all ${VAR:-default} patterns with actual env values
   content = content.replace(
@@ -52,6 +52,6 @@ export function processComposeEnv(
     return value ? yamlSafe(value) : _match
   })
 
-  writeFileSync(outputFile, content)
+  fs.writeFileSync(outputFile, content)
   console.info(`✅ processed compose file: ${outputFile}`)
 }

package/src/helpers/uncloud-deploy.ts

@@ -2,8 +2,7 @@
  * generic uncloud deployment helpers for ci/cd
  */
 
-import { existsSync } from 'node:fs'
-import { mkdir, writeFile } from 'node:fs/promises'
+import fs from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
@@ -91,7 +90,7 @@ export async function setupSSHKey() {
   const sshKeyValue = process.env.DEPLOY_SSH_KEY
 
   // check if it's a path to an existing file (local usage) or key content (CI usage)
-  if (existsSync(sshKeyValue)) {
+  if (fs.existsSync(sshKeyValue)) {
     console.info(`  using ssh key from: ${sshKeyValue}`)
     return
   }
@@ -101,8 +100,8 @@ export async function setupSSHKey() {
   const sshDir = join(homedir(), '.ssh')
   const keyPath = join(sshDir, 'uncloud_deploy')
 
-  if (!existsSync(sshDir)) {
-    await mkdir(sshDir, { recursive: true })
+  if (!fs.existsSync(sshDir)) {
+    await fs.promises.mkdir(sshDir, { recursive: true })
   }
 
   // decode base64-encoded keys (github secrets often store keys as base64)
@@ -120,7 +119,7 @@ export async function setupSSHKey() {
     keyContent += '\n'
   }
 
-  await writeFile(keyPath, keyContent, { mode: 0o600 })
+  await fs.promises.writeFile(keyPath, keyContent, { mode: 0o600 })
 
   // add host to known_hosts
   if (process.env.DEPLOY_HOST) {

package/src/helpers/uncloud.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import fs from 'node:fs'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
@@ -27,13 +27,13 @@ function ensureUncloudContext(host: string, sshKey: string, contextName: string)
   const configDir = join(homedir(), '.config', 'uncloud')
   const configPath = join(configDir, 'config.yaml')
 
-  if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true })
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true })
   }
 
   // check if config already has context pointing to correct host
-  if (existsSync(configPath)) {
-    const existing = readFileSync(configPath, 'utf-8')
+  if (fs.existsSync(configPath)) {
+    const existing = fs.readFileSync(configPath, 'utf-8')
     const hostname = host.split('@')[1]
     if (hostname && existing.includes(`${contextName}:`) && existing.includes(hostname)) {
       console.info(`✅ uncloud config already has ${contextName} context for ${host}`)
@@ -43,7 +43,7 @@ function ensureUncloudContext(host: string, sshKey: string, contextName: string)
 
   // only create config if it doesn't exist - don't overwrite existing config
   // which may have other contexts
-  if (!existsSync(configPath)) {
+  if (!fs.existsSync(configPath)) {
     const config = `current_context: ${contextName}
 contexts:
   ${contextName}:
@@ -51,7 +51,7 @@ contexts:
       - ssh: ${host}
         ssh_key_file: ${sshKey}
 `
-    writeFileSync(configPath, config)
+    fs.writeFileSync(configPath, config)
     console.info(`✅ created uncloud config at ${configPath}`)
   } else {
     console.info(`✅ using existing uncloud config (context: ${contextName})`)

package/src/helpers/zero-get-version.ts

@@ -1,8 +1,8 @@
-import { readFileSync } from 'node:fs'
+import fs from 'node:fs'
 import { join } from 'node:path'
 
 export function getZeroVersion() {
   const packageJsonPath = join(process.cwd(), 'package.json')
-  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'))
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
   return packageJson.dependencies?.['@rocicorp/zero']?.replace(/^[\^~]/, '')
 }

package/src/node-version-check.ts

@@ -1,5 +1,7 @@
 #!/usr/bin/env bun
 
+import fs from 'node:fs'
+
 import { cmd } from './cmd'
 
 function getCurrentNodeVersion() {
@@ -7,12 +9,11 @@ function getCurrentNodeVersion() {
 }
 
 async function getRequiredNodeVersion() {
-  const fs = await import('node:fs/promises')
   const path = await import('node:path')
 
   // try .node-version file first
   try {
-    const nodeVersionContent = await fs.readFile(
+    const nodeVersionContent = await fs.promises.readFile(
       path.join(process.cwd(), '.node-version'),
       'utf-8'
     )
@@ -22,7 +23,7 @@ async function getRequiredNodeVersion() {
   // fallback to package.json engines.node
   try {
     const packageJson = JSON.parse(
-      await fs.readFile(path.join(process.cwd(), 'package.json'), 'utf-8')
+      await fs.promises.readFile(path.join(process.cwd(), 'package.json'), 'utf-8')
     )
     return packageJson?.engines?.node ? `v${packageJson.engines.node}` : null
   } catch {

package/src/run.ts

@@ -5,7 +5,7 @@
  */
 
 import { spawn } from 'node:child_process'
-import { promises as fs } from 'node:fs'
+import fs from 'node:fs'
 import { join, relative, resolve } from 'node:path'
 
 import { handleProcessExit } from '@take-out/scripts/helpers/handleProcessExit'
@@ -101,7 +101,7 @@ if (runCommands.length === 0) {
 async function readPackageJson(directoryPath: string) {
   try {
     const packageJsonPath = join(directoryPath, 'package.json')
-    const content = await fs.readFile(packageJsonPath, 'utf8')
+    const content = await fs.promises.readFile(packageJsonPath, 'utf8')
     return JSON.parse(content)
   } catch (_) {
     return null
@@ -124,7 +124,7 @@ async function getWorkspacePatterns(): Promise<string[]> {
 
 async function hasPackageJson(path: string): Promise<boolean> {
   try {
-    await fs.access(join(path, 'package.json'))
+    await fs.promises.access(join(path, 'package.json'))
     return true
   } catch {
     return false
@@ -135,7 +135,7 @@ async function findPackageJsonDirs(basePath: string, maxDepth = 3): Promise<stri
   if (maxDepth <= 0) return []
 
   try {
-    const entries = await fs.readdir(basePath, { withFileTypes: true })
+    const entries = await fs.promises.readdir(basePath, { withFileTypes: true })
     const results: string[] = []
 
     if (await hasPackageJson(basePath)) {

package/src/up.ts

@@ -12,9 +12,6 @@ interface PackageJson {
 await cmd`upgrade packages by name or pattern`
   .args('--tag string --canary boolean --rc boolean')
   .run(async ({ args, $, path, fs }) => {
-    const { existsSync, readdirSync, readFileSync, writeFileSync, rmSync } =
-      await import('node:fs')
-
     let globalTag: string | undefined = args.tag
     if (args.canary) globalTag = 'canary'
     if (args.rc) globalTag = 'rc'
@@ -22,7 +19,7 @@ await cmd`upgrade packages by name or pattern`
     const packagePatterns: string[] = []
     const rootDir = process.cwd()
     const rootPackageJson = JSON.parse(
-      readFileSync(path.join(rootDir, 'package.json'), 'utf-8')
+      fs.readFileSync(path.join(rootDir, 'package.json'), 'utf-8')
     )
     const upgradeSets: Record<string, string[]> = rootPackageJson.upgradeSets || {}
 
@@ -54,14 +51,14 @@ await cmd`upgrade packages by name or pattern`
     function findPackageJsonFiles(dir: string): string[] {
       const results: string[] = []
 
-      if (existsSync(path.join(dir, 'package.json'))) {
+      if (fs.existsSync(path.join(dir, 'package.json'))) {
         results.push(path.join(dir, 'package.json'))
       }
 
       // check if it's a monorepo with workspaces
       try {
         const packageJson = JSON.parse(
-          readFileSync(path.join(dir, 'package.json'), 'utf-8')
+          fs.readFileSync(path.join(dir, 'package.json'), 'utf-8')
         )
         if (packageJson.workspaces) {
           let workspacePaths: string[] = []
@@ -81,15 +78,15 @@ await cmd`upgrade packages by name or pattern`
               const baseDir = normalizedWorkspace.split('**')[0]!.replace(/\/$/, '')
               const basePath = path.join(dir, baseDir)
 
-              if (existsSync(basePath)) {
+              if (fs.existsSync(basePath)) {
                 const findPackages = (searchDir: string) => {
                   try {
-                    const entries = readdirSync(searchDir, { withFileTypes: true })
+                    const entries = fs.readdirSync(searchDir, { withFileTypes: true })
                     for (const entry of entries) {
                       if (entry.isDirectory() && entry.name !== 'node_modules') {
                         const subPath = path.join(searchDir, entry.name)
                         const pkgPath = path.join(subPath, 'package.json')
-                        if (existsSync(pkgPath)) {
+                        if (fs.existsSync(pkgPath)) {
                           results.push(pkgPath)
                         }
                         // recurse into subdirectories
@@ -105,15 +102,16 @@ await cmd`upgrade packages by name or pattern`
             } else if (normalizedWorkspace.includes('*')) {
               // simple glob pattern like "packages/*"
               const workspaceDir = normalizedWorkspace.replace(/\/\*$/, '')
-              if (existsSync(path.join(dir, workspaceDir))) {
-                const subdirs = readdirSync(path.join(dir, workspaceDir), {
-                  withFileTypes: true,
-                })
+              if (fs.existsSync(path.join(dir, workspaceDir))) {
+                const subdirs = fs
+                  .readdirSync(path.join(dir, workspaceDir), {
+                    withFileTypes: true,
+                  })
                   .filter((dirent) => dirent.isDirectory())
                   .map((dirent) => path.join(dir, workspaceDir, dirent.name))
 
                 for (const subdir of subdirs) {
-                  if (existsSync(path.join(subdir, 'package.json'))) {
+                  if (fs.existsSync(path.join(subdir, 'package.json'))) {
                     results.push(path.join(subdir, 'package.json'))
                   }
                 }
@@ -121,7 +119,7 @@ await cmd`upgrade packages by name or pattern`
             } else {
               // exact path like "code/tamagui.dev" or "./code/sandbox"
               const pkgPath = path.join(dir, normalizedWorkspace, 'package.json')
-              if (existsSync(pkgPath)) {
+              if (fs.existsSync(pkgPath)) {
                 results.push(pkgPath)
               }
             }
@@ -136,7 +134,7 @@ await cmd`upgrade packages by name or pattern`
 
     function extractDependencies(packageJsonPath: string): string[] {
       try {
-        const content = readFileSync(packageJsonPath, 'utf-8')
+        const content = fs.readFileSync(packageJsonPath, 'utf-8')
         const packageJson = JSON.parse(content) as PackageJson
 
         const deps: string[] = []
@@ -176,7 +174,7 @@ await cmd`upgrade packages by name or pattern`
       packagesToUpdate: string[],
       versionMap: Map<string, string>
     ): number {
-      const content = readFileSync(packageJsonPath, 'utf-8')
+      const content = fs.readFileSync(packageJsonPath, 'utf-8')
       const packageJson = JSON.parse(content) as PackageJson
       let updatedCount = 0
 
@@ -214,7 +212,7 @@ await cmd`upgrade packages by name or pattern`
       updateDeps(packageJson.optionalDependencies)
 
       if (updatedCount > 0) {
-        writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n')
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n')
       }
 
       return updatedCount
@@ -226,7 +224,7 @@ await cmd`upgrade packages by name or pattern`
       packageJsonFiles: string[]
     ) {
       try {
-        rmSync(`node_modules/vite`, {
+        fs.rmSync(`node_modules/vite`, {
           recursive: true,
           force: true,
         })
@@ -338,7 +336,7 @@ await cmd`upgrade packages by name or pattern`
       if (packageJsonPath === path.join(rootDir, 'package.json')) continue
 
       try {
-        const content = readFileSync(packageJsonPath, 'utf-8')
+        const content = fs.readFileSync(packageJsonPath, 'utf-8')
         const packageJson = JSON.parse(content)
         if (packageJson.name) {
           workspacePackageNames.add(packageJson.name)
@@ -405,7 +403,7 @@ await cmd`upgrade packages by name or pattern`
       })
 
       // insert placeholder so updatePackageJsonVersions can set the real version
-      const rootPkg = JSON.parse(readFileSync(rootPkgPath, 'utf-8'))
+      const rootPkg = JSON.parse(fs.readFileSync(rootPkgPath, 'utf-8'))
       if (!rootPkg.dependencies) {
         rootPkg.dependencies = {}
       }
@@ -414,7 +412,7 @@ await cmd`upgrade packages by name or pattern`
           rootPkg.dependencies[pkg] = '*'
         }
       }
-      writeFileSync(rootPkgPath, JSON.stringify(rootPkg, null, 2) + '\n')
+      fs.writeFileSync(rootPkgPath, JSON.stringify(rootPkg, null, 2) + '\n')
     } else {
       console.info(
         `Found ${allMatchingDeps.size} dependencies matching patterns: ${packagePatterns.join(', ')}`

package/src/update-changelog.ts

@@ -1,18 +1,19 @@
 #!/usr/bin/env bun
 
+import fs from 'node:fs'
+
 import { cmd } from './cmd'
 
 await cmd`update changelog with recent git commits`.run(async ({ path }) => {
   const { execSync } = await import('node:child_process')
-  const { existsSync, readFileSync } = await import('node:fs')
 
   const CHANGELOG_PATH = path.join(process.cwd(), 'src/features/site/docs/changelog.mdx')
 
   function getLastSha(): string | null {
-    if (!existsSync(CHANGELOG_PATH)) return null
+    if (!fs.existsSync(CHANGELOG_PATH)) return null
 
     try {
-      const content = readFileSync(CHANGELOG_PATH, 'utf-8')
+      const content = fs.readFileSync(CHANGELOG_PATH, 'utf-8')
       const match = content.match(/\{\/\* last updated: ([a-f0-9]+) \*\/\}/)
       return match?.[1] || null
     } catch {

package/src/update-local-env.ts

@@ -1,18 +1,10 @@
 #!/usr/bin/env bun
 
+import fs from 'node:fs'
+
 import { cmd } from './cmd'
 
 await cmd`sync auto-generated env vars to local .env file`.run(async ({ path }) => {
-  const {
-    existsSync,
-    readFileSync,
-    writeFileSync,
-    copyFileSync,
-    renameSync,
-    unlinkSync,
-  } = await import('node:fs')
-  const { getZeroVersion } = await import('./helpers/zero-get-version')
-
   // skip in CI environments
   if (process.env.CI === 'true') {
     console.info('Skipping bootstrap in CI environment')
@@ -20,7 +12,6 @@ await cmd`sync auto-generated env vars to local .env file`.run(async ({ path })
   }
 
   const ENV_PATH = path.join(process.cwd(), '.env')
-  const ENV_TEMPLATE_PATH = path.join(process.cwd(), '.env.template')
   const ENV_BACKUP_PATH = path.join(process.cwd(), '.env.backup')
   const ENV_TEMP_PATH = path.join(process.cwd(), '.env.tmp')
 
@@ -28,56 +19,53 @@ await cmd`sync auto-generated env vars to local .env file`.run(async ({ path })
   const BEGIN_MARKER = '# ---- BEGIN AUTO-GENERATED (DO NOT EDIT) ----'
   const END_MARKER = '# ---- END AUTO-GENERATED ----'
 
-  function createEnvFromTemplate(): boolean {
-    if (!existsSync(ENV_TEMPLATE_PATH)) {
-      console.info('No .env.template found, skipping .env creation')
-      return false
-    }
-
-    try {
-      copyFileSync(ENV_TEMPLATE_PATH, ENV_PATH)
-      console.info('Created .env from .env.template')
-      return true
-    } catch (error) {
-      console.error('Failed to create .env from .env.template:', error)
-      return false
-    }
-  }
-
   function getAutoGeneratedContent(): string {
-    const zeroVersion = getZeroVersion()
-    if (!zeroVersion) {
-      console.warn('Could not determine Zero version')
+    const packageJsonPath = path.join(process.cwd(), 'package.json')
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'))
+    const envVars = packageJson.env as Record<string, boolean | string>
+
+    if (!envVars || typeof envVars !== 'object') {
+      console.warn('No env section found in package.json')
       return ''
     }
 
-    const lines = [
-      BEGIN_MARKER,
-      `# Generated at: ${new Date().toISOString()}`,
-      `ZERO_VERSION=${zeroVersion}`,
-      END_MARKER,
-    ]
+    const lines: string[] = [BEGIN_MARKER, `# Generated at: ${new Date().toISOString()}`]
+
+    for (const [key, value] of Object.entries(envVars)) {
+      if (typeof value === 'string' && value.startsWith('$dep:')) {
+        // resolve version from dependency
+        const depName = value.slice('$dep:'.length)
+        const version = packageJson.dependencies?.[depName]?.replace(/^[\^~]/, '')
+        if (version) {
+          lines.push(`${key}=${version}`)
+        } else {
+          console.warn(`Could not resolve dependency version for ${depName}`)
+        }
+      } else if (typeof value === 'string' && value !== '') {
+        // non-empty string default
+        lines.push(`${key}=${value}`)
+      }
+      // skip true (required, no default) and "" (no meaningful default)
+    }
 
+    lines.push(END_MARKER)
     return lines.join('\n')
   }
 
   function updateEnvFile(): void {
     // ensure .env exists
-    if (!existsSync(ENV_PATH)) {
-      const created = createEnvFromTemplate()
-      if (!created && !existsSync(ENV_PATH)) {
-        writeFileSync(ENV_PATH, '')
-        console.info('Created empty .env file')
-      }
+    if (!fs.existsSync(ENV_PATH)) {
+      fs.writeFileSync(ENV_PATH, '')
+      console.info('Created empty .env file')
     }
 
     try {
       // create backup
-      if (existsSync(ENV_PATH)) {
-        copyFileSync(ENV_PATH, ENV_BACKUP_PATH)
+      if (fs.existsSync(ENV_PATH)) {
+        fs.copyFileSync(ENV_PATH, ENV_BACKUP_PATH)
       }
 
-      const currentContent = readFileSync(ENV_PATH, 'utf-8')
+      const currentContent = fs.readFileSync(ENV_PATH, 'utf-8')
 
       const beginIndex = currentContent.indexOf(BEGIN_MARKER)
       const endIndex = currentContent.indexOf(END_MARKER)
@@ -107,20 +95,20 @@ await cmd`sync auto-generated env vars to local .env file`.run(async ({ path })
       }
 
       // write to temp file first (atomic operation)
-      writeFileSync(ENV_TEMP_PATH, newContent)
+      fs.writeFileSync(ENV_TEMP_PATH, newContent)
 
       // validate temp file
-      const tempContent = readFileSync(ENV_TEMP_PATH, 'utf-8')
+      const tempContent = fs.readFileSync(ENV_TEMP_PATH, 'utf-8')
       if (!tempContent.includes(BEGIN_MARKER) || !tempContent.includes(END_MARKER)) {
         throw new Error('Generated content validation failed')
       }
 
       // atomic replace
-      renameSync(ENV_TEMP_PATH, ENV_PATH)
+      fs.renameSync(ENV_TEMP_PATH, ENV_PATH)
 
-      if (existsSync(ENV_BACKUP_PATH)) {
+      if (fs.existsSync(ENV_BACKUP_PATH)) {
         try {
-          unlinkSync(ENV_BACKUP_PATH)
+          fs.unlinkSync(ENV_BACKUP_PATH)
         } catch {
           // ignore cleanup errors
         }
@@ -131,9 +119,9 @@ await cmd`sync auto-generated env vars to local .env file`.run(async ({ path })
       console.error('Failed to update .env file:', error)
 
       // attempt to restore backup
-      if (existsSync(ENV_BACKUP_PATH)) {
+      if (fs.existsSync(ENV_BACKUP_PATH)) {
         try {
-          copyFileSync(ENV_BACKUP_PATH, ENV_PATH)
+          fs.copyFileSync(ENV_BACKUP_PATH, ENV_PATH)
           console.info('Restored .env from backup')
         } catch (restoreError) {
           console.error('Failed to restore backup:', restoreError)
@@ -141,9 +129,9 @@ await cmd`sync auto-generated env vars to local .env file`.run(async ({ path })
       }
 
       // clean up temp file
-      if (existsSync(ENV_TEMP_PATH)) {
+      if (fs.existsSync(ENV_TEMP_PATH)) {
         try {
-          unlinkSync(ENV_TEMP_PATH)
+          fs.unlinkSync(ENV_TEMP_PATH)
         } catch {
           // ignore cleanup errors
         }