@take-out/scripts 0.3.1 → 0.4.1-1775377981053

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.3.1",
+  "version": "0.4.1-1775377981053",
   "type": "module",
   "main": "./src/cmd.ts",
   "sideEffects": false,
@@ -29,8 +29,8 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.8.2",
-    "@take-out/helpers": "0.3.1",
-    "@take-out/run": "0.3.1",
+    "@take-out/helpers": "0.4.1-1775377981053",
+    "@take-out/run": "0.4.1-1775377981053",
     "picocolors": "^1.1.1"
   }
 }

package/src/env-update.ts

@@ -4,17 +4,9 @@ import fs from 'node:fs'
 import path from 'node:path'
 
 import { cmd } from './cmd'
-import { resolveDepVersion } from './helpers/resolve-dep-version'
 
 const PRESETS: Record<string, string[]> = {
-  takeout: [
-    '.github/workflows/*.yml',
-    'src/uncloud/*.yml',
-    '.env*',
-    'src/env.ts',
-    'src/constants/env-server.ts',
-    'src/server/env-server.ts',
-  ],
+  takeout: ['.github/workflows/*.yml', 'src/uncloud/*.yml', '.env*'],
 }
 
 const IGNORE_DIRS = new Set([
@@ -27,26 +19,45 @@ const IGNORE_DIRS = new Set([
   '.docker',
 ])
 
-await cmd`sync environment variables from package.json to matching files`
+await cmd`sync environment variables from src/env.ts to matching files`
   .args('--preset string')
   .run(async ({ args }) => {
-    const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'))
-    const envVars = packageJson.env as Record<string, boolean | string>
+    // import env var definitions from src/env.ts (the single source of truth)
+    const envModule = await import(path.resolve('src/env.ts'))
+    const envVars = envModule.envVars as Record<string, string | symbol>
+    const envDeps = (envModule.envDeps || {}) as Record<string, string>
 
-    if (!envVars || Array.isArray(envVars) || typeof envVars !== 'object') {
-      console.error('No environment variables found in package.json')
+    if (!envVars || typeof envVars !== 'object') {
+      console.error('no envVars export found in src/env.ts')
       process.exit(1)
     }
 
-    // resolve $dep: values
+    // the expected symbol from @take-out/env
+    const expectedSymbol = Symbol.for('take-out/env/expected')
+
+    // resolve dep versions from package.json dependencies
+    const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'))
     const depResolved: Record<string, string> = {}
-    for (const [key, value] of Object.entries(envVars)) {
-      const dep = resolveDepVersion(value, packageJson.dependencies)
-      if (dep) {
-        depResolved[key] = dep
+    for (const [key, depName] of Object.entries(envDeps)) {
+      const version = packageJson.dependencies?.[depName]?.replace(/^[\^~]/, '')
+      if (version) {
+        depResolved[key] = version
+        // add dep-resolved vars to envVars with resolved value
+        envVars[key] = version
       }
     }
 
+    // normalize envVars: expected symbol → true (required), string → string
+    // for compatibility with strategy functions
+    type EnvEntry = { key: string; required: boolean; defaultValue: string }
+    const entries: EnvEntry[] = Object.entries(envVars)
+      .map(([key, value]) => ({
+        key,
+        required: value === expectedSymbol,
+        defaultValue: typeof value === 'string' ? value : '',
+      }))
+      .sort((a, b) => a.key.localeCompare(b.key))
+
     // load .gitignore patterns
     const gitignorePatterns: string[] = []
     try {
@@ -102,13 +113,13 @@ await cmd`sync environment variables from package.json to matching files`
       )
 
       function walk(dir: string) {
-        let entries: fs.Dirent[]
+        let dirEntries: fs.Dirent[]
         try {
-          entries = fs.readdirSync(dir, { withFileTypes: true })
+          dirEntries = fs.readdirSync(dir, { withFileTypes: true })
         } catch {
           return
         }
-        for (const entry of entries) {
+        for (const entry of dirEntries) {
           const full = dir === '.' ? entry.name : `${dir}/${entry.name}`
           if (isRecursive && isIgnored(full)) continue
           if (entry.isDirectory()) {
@@ -156,37 +167,23 @@ await cmd`sync environment variables from package.json to matching files`
     const markerEnd = '🔒 end - this is generated by "bun env:update"'
     const yamlStart = `# ${markerStart}`
     const yamlEnd = `# ${markerEnd}`
-    const jsStart = `// ${markerStart}`
-    const jsEnd = `// ${markerEnd}`
-
     // .env auto-generated section markers
     const dotenvSectionStart = '# ---- BEGIN AUTO-GENERATED (DO NOT EDIT) ----'
     const dotenvSectionEnd = '# ---- END AUTO-GENERATED ----'
 
-    type Strategy =
-      | 'yaml-markers'
-      | 'js-markers'
-      | 'dotenv-section'
-      | 'dotenv-inline'
-      | 'ts-inline'
+    type Strategy = 'yaml-markers' | 'dotenv-section' | 'dotenv-inline'
 
     function detectStrategy(filePath: string, content: string): Strategy | null {
       if (content.includes(yamlStart) && content.includes(yamlEnd)) {
         return 'yaml-markers'
       }
-      if (content.includes(jsStart) && content.includes(jsEnd)) {
-        return 'js-markers'
-      }
       const basename = path.basename(filePath)
       if (basename === '.env') {
         return 'dotenv-section'
       }
-      if (/^\.env/.test(basename)) {
+      if (/^\.env/.test(basename) && Object.keys(depResolved).length > 0) {
         return 'dotenv-inline'
       }
-      if (filePath.endsWith('.ts') && Object.keys(depResolved).length > 0) {
-        return 'ts-inline'
-      }
       return null
     }
 
@@ -219,10 +216,10 @@ await cmd`sync environment variables from package.json to matching files`
       const isMap = /x-[\w-]+:.*&[\w-]+/s.test(beforeMarker)
       const isGithubActions = filePath.includes('.github/workflows')
 
-      const envLines = Object.entries(envVars)
-        .map(([key, value]) => {
-          const dep = resolveDepVersion(value, packageJson.dependencies)
-          const defaultVal = dep || (typeof value === 'string' ? value : '')
+      const envLines = entries
+        .map(({ key, defaultValue }) => {
+          const dep = depResolved[key]
+          const val = dep || defaultValue
 
           if (isGithubActions) {
             return dep
@@ -231,40 +228,23 @@ await cmd`sync environment variables from package.json to matching files`
           }
 
           return isMap
-            ? `${indent}${key}: \${${key}:-${defaultVal}}`
-            : `${indent}- ${key}=\${${key}:-${defaultVal}}`
+            ? `${indent}${key}: \${${key}:-${val}}`
+            : `${indent}- ${key}=\${${key}:-${val}}`
         })
         .join('\n')
 
       return replaceMarkerSection(content, yamlStart, yamlEnd, envLines)
     }
 
-    function applyJsMarkers(_filePath: string, content: string): string {
-      const envExports = Object.entries(envVars)
-        .map(([key, value]) => {
-          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')
-
-      return replaceMarkerSection(content, jsStart, jsEnd, envExports)
-    }
-
     function applyDotenvSection(_filePath: string, content: string): string {
       const lines: string[] = [dotenvSectionStart]
 
-      for (const [key, value] of Object.entries(envVars)) {
-        const dep = resolveDepVersion(value, packageJson.dependencies)
+      for (const { key, required, defaultValue } of entries) {
+        const dep = depResolved[key]
         if (dep) {
           lines.push(`${key}=${dep}`)
-        } else if (typeof value === 'string' && value.startsWith('$dep:')) {
-          console.warn(
-            `could not resolve dependency version for ${value.slice('$dep:'.length)}`,
-          )
-        } else if (typeof value === 'string' && value !== '') {
-          lines.push(`${key}=${value}`)
+        } else if (!required && defaultValue !== '') {
+          lines.push(`${key}=${defaultValue}`)
         }
       }
 
@@ -297,24 +277,10 @@ await cmd`sync environment variables from package.json to matching files`
       return result
     }
 
-    function applyTsInline(_filePath: string, content: string): string {
-      let result = content
-      for (const [key, value] of Object.entries(depResolved)) {
-        const re = new RegExp(`(${key}:\\s*)(['"])([^'"]+)\\2`, 'g')
-        result = result.replace(re, (_match, prefix, quote, oldValue) => {
-          if (oldValue !== value) return `${prefix}${quote}${value}${quote}`
-          return _match
-        })
-      }
-      return result
-    }
-
     const strategies: Record<Strategy, (filePath: string, content: string) => string> = {
       'yaml-markers': applyYamlMarkers,
-      'js-markers': applyJsMarkers,
       'dotenv-section': applyDotenvSection,
       'dotenv-inline': applyDotenvInline,
-      'ts-inline': applyTsInline,
     }
 
     let updated = 0

package/src/helpers/deploy-lock.ts

@@ -56,3 +56,53 @@ export async function releaseDeployLock(
     // best-effort, lock will auto-expire
   }
 }
+
+/**
+ * run `fn` with the deploy lock held, releasing on ANY exit path —
+ * normal return, thrown error, or process signal (SIGTERM from CI cancel,
+ * SIGINT from ctrl-c, SIGHUP from terminal close).
+ *
+ * prefer this over raw acquire/release: a bare try/finally does NOT catch
+ * signals, so a CI-cancelled deploy would leak the lock for 15 minutes and
+ * block the next run. this helper installs signal handlers that release
+ * before exit, then removes them once `fn` completes.
+ */
+export async function withDeployLock<T>(
+  ssh: string,
+  fn: () => Promise<T>,
+  opts?: DeployLockOptions,
+): Promise<T> {
+  await acquireDeployLock(ssh, opts)
+
+  let released = false
+  const release = async () => {
+    if (released) return
+    released = true
+    await releaseDeployLock(ssh, opts)
+  }
+
+  // signal handlers — fire-and-forget release with a safety timeout so the
+  // process always exits even if the ssh release hangs
+  const signals: NodeJS.Signals[] = ['SIGTERM', 'SIGINT', 'SIGHUP']
+  const handlers = new Map<NodeJS.Signals, () => void>()
+  for (const sig of signals) {
+    const handler = () => {
+      const done = release().catch(() => {})
+      const timeout = new Promise<void>((r) => setTimeout(r, 5_000))
+      Promise.race([done, timeout]).finally(() => {
+        process.exit(sig === 'SIGINT' ? 130 : 143)
+      })
+    }
+    handlers.set(sig, handler)
+    process.once(sig, handler)
+  }
+
+  try {
+    return await fn()
+  } finally {
+    for (const [sig, handler] of handlers) {
+      process.off(sig, handler)
+    }
+    await release()
+  }
+}

package/src/helpers/env-load.ts

@@ -1,18 +1,17 @@
-import fs from 'node:fs'
 import { join } from 'node:path'
 
 export async function loadEnv(
   environment: 'development' | 'production' | 'dev-prod',
-  options?: { optional?: string[]; envPath?: string },
+  options?: { optional?: string[] },
 ) {
   const { loadEnv: vxrnLoadEnv } = await import('vxrn/loadEnv')
 
   // loads env into process.env
   await vxrnLoadEnv(environment)
 
-  const envPath = options?.envPath || resolveEnvServerPath()
-
-  const Environment = await import(envPath)
+  // import src/env.ts to get the env config applied (side effect: populates process.env)
+  const envModule = await import(join(process.cwd(), 'src/env.ts'))
+  const Environment = envModule.server || {}
 
   // validate
   for (const key in Environment) {
@@ -26,15 +25,3 @@ export async function loadEnv(
 
   return Environment
 }
-
-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 (fs.existsSync(full)) {
-      return full
-    }
-  }
-  // fall back to first candidate for error message
-  return join(process.cwd(), 'src/constants/env-server.ts')
-}

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

@@ -1,4 +1,3 @@
-import fs from 'node:fs'
 import { join } from 'node:path'
 
 import { loadEnv } from './env-load'
@@ -7,12 +6,10 @@ import { getDockerHost } from './get-docker-host'
 export async function getTestEnv() {
   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) => fs.existsSync(p + '.ts')) ||
-    join(process.cwd(), 'src/constants/env-server')
-  const serverEnvFallback = await import(envPath)
+
+  // import src/env.ts for server env fallback values
+  const envModule = await import(join(process.cwd(), 'src/env.ts'))
+  const serverEnvFallback = envModule.server || {}
 
   // ports come from VITE_PORT_* in .env.development (loaded by loadEnv)
   const dbPort = process.env.VITE_PORT_POSTGRES || '5433'