@take-out/scripts 0.0.64 → 0.0.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.0.64",
+  "version": "0.0.66",
   "type": "module",
   "main": "./src/run.ts",
   "sideEffects": false,

package/src/ensure-tunnel.ts

@@ -1,6 +1,8 @@
 #!/usr/bin/env bun
 
-const netstat = Bun.spawnSync(`netstat -rn`.split(' ')).stdout
+import { spawnSync } from 'node:child_process'
+
+const netstat = spawnSync('netstat', ['-rn'], { encoding: 'utf-8' }).stdout || ''
 const isTunnelActive = netstat.includes(`10.0.8/22`)
 
 if (!isTunnelActive) {

package/src/exec-with-env.ts

@@ -1,5 +1,7 @@
 #!/usr/bin/env bun
 
+import { spawnSync } from 'node:child_process'
+
 import { ensureExists } from '@take-out/helpers'
 import { loadEnv } from '@take-out/scripts/helpers/env-load'
 
@@ -40,10 +42,9 @@ export async function execWithEnvironment(
     }),
   } as any as Record<string, string>
 
-  return Bun.spawnSync(command.split(' '), {
-    stdin: 'ignore',
-    stdout: 'inherit',
-    stderr: 'inherit',
+  const parts = command.split(' ')
+  return spawnSync(parts[0]!, parts.slice(1), {
+    stdio: ['ignore', 'inherit', 'inherit'],
     env,
   })
 }
@@ -53,5 +54,5 @@ if (import.meta.main) {
     (process.env.NODE_ENV as 'development' | 'production') || 'development',
     process.argv.slice(3).join(' ')
   )
-  process.exit(result.exitCode)
+  process.exit(result.status ?? 1)
 }

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

@@ -1,60 +1,22 @@
-import { readFileSync } 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'
 
-// extract the port from a postgres connection string
-function getPortFromConnectionString(url: string | undefined): string | undefined {
-  if (!url) return undefined
-  try {
-    // handle postgresql:// URLs
-    const match = url.match(/:(\d+)\//)
-    return match?.[1]
-  } catch {
-    return undefined
-  }
-}
-
-// 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 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 .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 || getDevDbPort() || '5432'
+  // ports come from VITE_PORT_* in .env.development (loaded by loadEnv)
+  const dbPort = process.env.VITE_PORT_POSTGRES || '5433'
+  const appPort = process.env.VITE_PORT_WEB || '8081'
+  const minioPort = process.env.VITE_PORT_MINIO || '9200'
 
   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,
@@ -64,16 +26,14 @@ export async function getTestEnv() {
     }),
     DO_NOT_TRACK: '1',
     ZERO_VERSION: zeroVersion,
-    ZERO_MUTATE_URL: `http://${dockerHost}:8081/api/zero/push`,
-    ZERO_QUERY_URL: `http://${dockerHost}:8081/api/zero/pull`,
+    ZERO_MUTATE_URL: `http://${dockerHost}:${appPort}/api/zero/push`,
+    ZERO_QUERY_URL: `http://${dockerHost}:${appPort}/api/zero/pull`,
     ZERO_UPSTREAM_DB: `${dockerDbBase}/postgres`,
     ZERO_CVR_DB: `${dockerDbBase}/zero_cvr`,
     ZERO_CHANGE_DB: `${dockerDbBase}/zero_cdb`,
-    CLOUDFLARE_R2_ENDPOINT: 'http://127.0.0.1:9200',
-    CLOUDFLARE_R2_PUBLIC_URL: 'http://127.0.0.1:9200',
+    CLOUDFLARE_R2_ENDPOINT: `http://127.0.0.1:${minioPort}`,
+    CLOUDFLARE_R2_PUBLIC_URL: `http://127.0.0.1:${minioPort}`,
     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

@@ -1,9 +1,9 @@
+import { spawn, type ChildProcess } from 'node:child_process'
 import { cpus } from 'node:os'
 
 import type { Timer } from '@take-out/helpers'
-import type { ChildProcess } from 'node:child_process'
 
-export type ProcessType = ChildProcess | Bun.Subprocess
+export type ProcessType = ChildProcess
 export type ProcessHandler = (process: ProcessType) => void
 
 // track if we're in cleanup state (another process failed)
@@ -94,11 +94,11 @@ export async function run(
     let didTimeOut = false
 
     try {
-      const shell = Bun.spawn(['bash', '-c', command], {
+      const shell = spawn('bash', ['-c', command], {
         env: { ...process.env, ...env },
         cwd,
-        stdout: 'pipe',
-        stderr: 'pipe', // always pipe stderr so we can capture it for error messages
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: detached ?? false,
       })
 
       if (detached) {
@@ -128,27 +128,26 @@ export async function run(
         }
       }
 
-      const processStream = async (
-        stream: ReadableStream<Uint8Array> | undefined,
+      const processStream = (
+        stream: NodeJS.ReadableStream | null,
         isStderr: boolean
       ): Promise<string> => {
-        if (effectiveSilent && !captureOutput) {
-          return ''
-        }
-
-        if (!stream) return ''
+        return new Promise((resolve) => {
+          if (effectiveSilent && !captureOutput) {
+            resolve('')
+            return
+          }
 
-        let buffer = ''
-        let captured = ''
-        const decoder = new TextDecoder()
-        const reader = stream.getReader()
+          if (!stream) {
+            resolve('')
+            return
+          }
 
-        try {
-          while (true) {
-            const { done, value } = await reader.read()
-            if (done) break
+          let buffer = ''
+          let captured = ''
 
-            const text = buffer + decoder.decode(value, { stream: true })
+          stream.on('data', (chunk: Buffer) => {
+            const text = buffer + chunk.toString()
             const lines = text.split('\n')
 
             // keep last partial line in buffer
@@ -164,32 +163,35 @@ export async function run(
                 writeOutput(line + '\n', isStderr)
               }
             }
-          }
+          })
 
-          // output any remaining buffer
-          if (buffer) {
-            captured += buffer
-            if (!captureOutput || prefix) {
-              writeOutput(buffer + '\n', isStderr)
+          stream.on('end', () => {
+            // output any remaining buffer
+            if (buffer) {
+              captured += buffer
+              if (!captureOutput || prefix) {
+                writeOutput(buffer + '\n', isStderr)
+              }
             }
-          }
-        } catch (err) {
-          console.error(`Error reading stream!`, err)
-        } finally {
-          reader.releaseLock()
-        }
-
-        return captured
+            resolve(captured)
+          })
+
+          stream.on('error', (err) => {
+            console.error(`Error reading stream!`, err)
+            resolve(captured)
+          })
+        })
       }
 
-      // always process both streams
-      const [stdout, stderr] = await Promise.all([
+      // process both streams and wait for exit
+      const [stdout, stderr, exitCode] = await Promise.all([
         processStream(shell.stdout, false),
         processStream(shell.stderr, true),
+        new Promise<number | null>((resolve) => {
+          shell.on('close', (code) => resolve(code))
+        }),
       ])
 
-      const exitCode = await shell.exited
-
       if (timeoutId) {
         clearTimeout(timeoutId)
       }

package/src/release.ts

@@ -190,10 +190,13 @@ async function main() {
           // pack with bun (properly converts workspace:* to versions)
           // use swap-exports for packages with build scripts, otherwise just pack
           if (json.scripts?.build) {
-            await run(`bun run build --swap-exports -- bun pm pack --filename ${tgzPath}`, {
-              cwd,
-              silent: true,
-            })
+            await run(
+              `bun run build --swap-exports -- bun pm pack --filename ${tgzPath}`,
+              {
+                cwd,
+                silent: true,
+              }
+            )
           } else {
             await run(`bun pm pack --filename ${tgzPath}`, {
               cwd,

package/src/sst-get-environment.ts

@@ -1,18 +1,21 @@
 #!/usr/bin/env bun
 
+import { spawnSync } from 'node:child_process'
+
 export function getEnvironment(resourceName: string) {
   if (!resourceName) {
     console.error(`No resouce name given:
-      
+
       bun scripts/get-environment.ts [resourceName]
   `)
     process.exit(1)
   }
 
   console.info(`Getting environment for ${resourceName}...`)
-  const state = JSON.parse(
-    Bun.spawnSync(`bun sst state export --stage production`.split(' ')).stdout.toString()
-  )
+  const result = spawnSync('bun', ['sst', 'state', 'export', '--stage', 'production'], {
+    encoding: 'utf-8',
+  })
+  const state = JSON.parse(result.stdout || '{}')
 
   const resource = state.latest.resources.find(
     (x: any) => x.outputs?._dev?.title === resourceName