@take-out/scripts 0.0.62 → 0.0.65

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@take-out/scripts",
-  "version": "0.0.62",
+  "version": "0.0.65",
   "type": "module",
   "main": "./src/run.ts",
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./types/run.d.ts",
+      "types": "./src/run.ts",
       "default": "./src/run.ts"
     },
     "./package.json": "./package.json",
     "./helpers/*": {
-      "types": "./types/helpers/*.d.ts",
+      "types": "./src/helpers/*.ts",
       "default": "./src/helpers/*.ts"
     },
     "./*": {
-      "types": "./types/*.d.ts",
+      "types": "./src/*.ts",
       "default": "./src/*.ts"
     }
   },

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

@@ -36,18 +36,27 @@ function getDevDbPort(): string | undefined {
   return url ? getPortFromConnectionString(url) : undefined
 }
 
+// extract port from a URL like http://localhost:8081
+function getPortFromUrl(url: string | undefined): string | undefined {
+  if (!url) return undefined
+  try {
+    const parsed = new URL(url)
+    return parsed.port || undefined
+  } catch {
+    return 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'
+  // read ports from PORT_* env vars (set in .env.development) to support per-project configuration
+  const dbPort = process.env.PORT_POSTGRES || getDevEnvVar('PORT_POSTGRES') || '5433'
+  const appPort = process.env.PORT_WEB || getDevEnvVar('PORT_WEB') || '8081'
+  const minioPort = process.env.PORT_MINIO || getDevEnvVar('PORT_MINIO') || '9200'
 
   const dockerDbBase = `postgresql://user:password@127.0.0.1:${dbPort}`
 
@@ -64,13 +73,13 @@ 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

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

@@ -1,10 +1,11 @@
+import { tmpdir } from 'node:os'
 import path, { join } from 'node:path'
 
 // note! this is an helper script used by tamagui team for publishing the takeout packages
 // you can delete this from your own app
 
 import { run } from '@take-out/scripts/helpers/run'
-import fs, { ensureDir, writeJSON } from 'fs-extra'
+import fs, { writeJSON } from 'fs-extra'
 import pMap from 'p-map'
 
 // avoid emitter error
@@ -170,104 +171,62 @@ async function main() {
       )
     }
 
-    if (!finish && dryRun) {
-      console.info(`Dry run, exiting before publish`)
-      return
-    }
-
     if (!finish && !rePublish) {
       await run(`git diff`)
     }
 
     if (!finish) {
-      const tmpDir = `/tmp/one-publish`
-      // clean up from previous runs
-      await fs.remove(tmpDir)
-      await ensureDir(tmpDir)
+      const packDir = join(tmpdir(), `takeout-release-${nextVersion}`)
+      await fs.ensureDir(packDir)
 
       await pMap(
         packageJsons,
-        async ({ name, cwd }) => {
-          const publishOptions = [canary && `--tag canary`].filter(Boolean).join(' ')
-
-          // pack with workspace:* converted to versions
-          const tmpPackageDir = join(tmpDir, name.replace('/', '_'))
-          await fs.copy(cwd, tmpPackageDir, {
-            filter: (src) => {
-              // exclude node_modules to avoid symlink issues
-              return !src.includes('node_modules')
-            },
-          })
+        async ({ name, cwd, json }) => {
+          const publishOptions = [canary && `--tag canary`, dryRun && `--dry-run`]
+            .filter(Boolean)
+            .join(' ')
+          const tgzPath = join(packDir, `${name.replace('/', '-')}.tgz`)
 
-          // replace workspace:* with version
-          const pkgJsonPath = join(tmpPackageDir, 'package.json')
-          const pkgJson = await fs.readJSON(pkgJsonPath)
-          for (const field of [
-            'dependencies',
-            'devDependencies',
-            'optionalDependencies',
-            'peerDependencies',
-          ]) {
-            if (!pkgJson[field]) continue
-            for (const depName in pkgJson[field]) {
-              if (pkgJson[field][depName].startsWith('workspace:')) {
-                pkgJson[field][depName] = nextVersion
-              }
-            }
-          }
-          await writeJSON(pkgJsonPath, pkgJson, { spaces: 2 })
-
-          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')
-                }
+          // 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,
               }
-            }
-            swapTypes(pkgJson.exports)
-            await writeJSON(pkgJsonPath, pkgJson, { spaces: 2 })
+            )
+          } else {
+            await run(`bun pm pack --filename ${tgzPath}`, {
+              cwd,
+              silent: true,
+            })
           }
 
-          await run(`npm pack --pack-destination ${tmpDir}`, {
-            cwd: tmpPackageDir,
+          // publish the tgz directly
+          await run(`npm publish ${tgzPath} ${publishOptions}`.trim(), {
+            cwd: packDir,
             silent: true,
           })
 
-          // rename npm's output to our expected filename
-          const npmFilename = `${name.replace('@', '').replace('/', '-')}-${nextVersion}.tgz`
-          await fs.rename(join(tmpDir, npmFilename), absolutePath)
-
-          const publishCommand = ['npm publish', absolutePath, publishOptions]
-            .filter(Boolean)
-            .join(' ')
-
-          console.info(`Publishing ${name}: ${publishCommand}`)
-
-          await run(publishCommand, {
-            cwd: tmpDir,
-          }).catch((err) => console.error(err))
+          console.info(`${dryRun ? '[dry-run] ' : ''}Published ${name}`)
         },
         {
           concurrency: 15,
         }
       )
 
-      console.info(`✅ Published\n`)
+      console.info(`✅ ${dryRun ? '[dry-run] ' : ''}Published\n`)
+
+      // revert version changes after dry-run
+      if (dryRun) {
+        await run(`git checkout -- packages/*/package.json`, { silent: true })
+        console.info('Reverted version changes\n')
+      }
     }
 
-    if (!skipFinish) {
+    if (!skipFinish && !dryRun) {
       // then git tag, commit, push
       if (!finish) {
         await run(`bun install`)

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