@take-out/scripts 0.4.0 → 0.4.1-1775539666978

package/package.json

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

package/src/env-update.ts

@@ -24,33 +24,27 @@ await cmd`sync environment variables from src/env.ts to matching files`
   .run(async ({ args }) => {
     // 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>
+    const production = envModule.production as Record<string, string | symbol>
+    const versions = (envModule.versions || {}) as Record<string, string>
 
-    if (!envVars || typeof envVars !== 'object') {
-      console.error('no envVars export found in src/env.ts')
+    if (!production || typeof production !== 'object') {
+      console.error('no production export found in src/env.ts')
       process.exit(1)
     }
 
     // the expected symbol from @take-out/env
     const expectedSymbol = Symbol.for('take-out/env/expected')
 
-    // resolve dep versions from package.json dependencies
+    // merge resolved versions into the var registry
     const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf-8'))
-    const depResolved: Record<string, string> = {}
-    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
-      }
+    const depResolved = { ...versions }
+    for (const [key, value] of Object.entries(versions)) {
+      production[key] = value
     }
 
-    // normalize envVars: expected symbol → true (required), string → string
-    // for compatibility with strategy functions
+    // normalize: expected symbol → required, string → defaultValue
     type EnvEntry = { key: string; required: boolean; defaultValue: string }
-    const entries: EnvEntry[] = Object.entries(envVars)
+    const entries: EnvEntry[] = Object.entries(production)
       .map(([key, value]) => ({
         key,
         required: value === expectedSymbol,

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()
+  }
+}