@steve31415/baselib 3.39.0 → 3.39.1

package/dist/bin/pw-deploy.js

@@ -3,12 +3,14 @@
 // ~/migration/research/deploy-procedure-design.md). All logic lives in
 // ../deploy/deploy.ts; configuration is the app's deploy.config.json.
 //
-// process.exit (not exitCode) so an in-flight Cloud Build child cannot keep
-// a failed deploy's process alive; the server-side build finishes on its own
-// and is reused by the next attempt.
+// An explicit exit (not exitCode) so an in-flight Cloud Build child cannot
+// keep a failed deploy's process alive; the server-side build finishes on its
+// own and is reused by the next attempt. exitWhenFlushed lets the output
+// already written reach a piped reader (Coder captures it) first.
+import { exitWhenFlushed } from '../ops/cli.js';
 import { realRunner } from '../deploy/exec.js';
 import { runDeploy } from '../deploy/deploy.js';
-process.exit(await runDeploy({
+await exitWhenFlushed(await runDeploy({
     repoRoot: process.cwd(),
     runner: realRunner,
     argv: process.argv.slice(2),

package/dist/bin/pw-logs.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 // `pw-logs` — Axiom log query (OPERATIONS.md "Investigating production
 // state"). All logic lives in ../ops/logs.ts.
+import { exitWhenFlushed } from '../ops/cli.js';
 import { runLogs } from '../ops/logs.js';
-process.exit(await runLogs({ argv: process.argv.slice(2), cwd: process.cwd() }));
+await exitWhenFlushed(await runLogs({ argv: process.argv.slice(2), cwd: process.cwd() }));

package/dist/bin/pw-rollback.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 // `pw-rollback` — one-command traffic move to a previously released build.
 // All logic lives in ../deploy/rollback.ts.
+import { exitWhenFlushed } from '../ops/cli.js';
 import { realRunner } from '../deploy/exec.js';
 import { runRollback } from '../deploy/rollback.js';
-process.exit(await runRollback({
+await exitWhenFlushed(await runRollback({
     repoRoot: process.cwd(),
     runner: realRunner,
     argv: process.argv.slice(2),

package/dist/bin/pw-sql.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 // `pw-sql` — read-only production SQL (OPERATIONS.md "Investigating
 // production state"). All logic lives in ../ops/sql.ts.
+import { exitWhenFlushed } from '../ops/cli.js';
 import { runSql } from '../ops/sql.js';
-process.exit(await runSql({ argv: process.argv.slice(2), cwd: process.cwd() }));
+await exitWhenFlushed(await runSql({ argv: process.argv.slice(2), cwd: process.cwd() }));

package/dist/bin/release.js

@@ -2,6 +2,7 @@
 // baselib's `npm run deploy` — release the checked-out version (tag push +
 // wait for the registry; the tag-triggered workflow does the actual
 // publish). All logic lives in ../release.ts.
+import { exitWhenFlushed } from '../ops/cli.js';
 import { realRunner } from '../deploy/exec.js';
 import { release } from '../release.js';
 try {
@@ -12,5 +13,5 @@ try {
 }
 catch (e) {
     console.error(e instanceof Error ? e.message : String(e));
-    process.exit(1);
+    await exitWhenFlushed(1);
 }

package/dist/ops/cli.d.ts

@@ -13,4 +13,16 @@ type Parsed<T extends Options> = ReturnType<typeof parseArgs<{
 export declare function parseCli<T extends Options>(argv: string[], options: T, usage: string, io: CliIo): Parsed<T> | {
     code: number;
 };
+/**
+ * `process.exit(code)` once stdout and stderr have handed everything written
+ * to them to the OS. A plain process.exit discards what a pipe has not yet
+ * taken: Node writes to a pipe asynchronously once its buffer (64 KiB on
+ * Linux) is full, so `pw-logs … | jq` lost all but the first 64 KiB, with
+ * exit status 0 (2026-10-26). Files and terminals are written synchronously,
+ * which is why redirecting to a file never showed it. Still an explicit exit,
+ * not `exitCode`: nothing else the bin started (a connection pool, a Cloud
+ * Build child) may keep it alive. A reader that goes away (`| head`) ends the
+ * wait instead of crashing the bin on EPIPE.
+ */
+export declare function exitWhenFlushed(code: number, streams?: NodeJS.WritableStream[], exit?: (code: number) => void): Promise<void>;
 export {};

package/dist/ops/cli.js

@@ -25,3 +25,29 @@ export function parseCli(argv, options, usage, io) {
     }
     return parsed;
 }
+/**
+ * `process.exit(code)` once stdout and stderr have handed everything written
+ * to them to the OS. A plain process.exit discards what a pipe has not yet
+ * taken: Node writes to a pipe asynchronously once its buffer (64 KiB on
+ * Linux) is full, so `pw-logs … | jq` lost all but the first 64 KiB, with
+ * exit status 0 (2026-10-26). Files and terminals are written synchronously,
+ * which is why redirecting to a file never showed it. Still an explicit exit,
+ * not `exitCode`: nothing else the bin started (a connection pool, a Cloud
+ * Build child) may keep it alive. A reader that goes away (`| head`) ends the
+ * wait instead of crashing the bin on EPIPE.
+ */
+export async function exitWhenFlushed(code, streams = [process.stdout, process.stderr], exit = (c) => process.exit(c)) {
+    await Promise.all(streams.map(flushed));
+    exit(code);
+}
+function flushed(stream) {
+    return new Promise((resolve) => {
+        // A broken pipe is reported to the write callback and then, a tick
+        // later, as an 'error' event, which would crash the process if nothing
+        // listened — so the listener stays until the exit.
+        stream.on('error', () => resolve());
+        // Writes complete in order, so an empty write's callback runs only after
+        // everything written before it has gone out.
+        stream.write('', () => resolve());
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.39.0",
+  "version": "3.39.1",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",