@steve31415/baselib 3.39.0 → 3.40.0

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/llm/complete.js

@@ -83,6 +83,7 @@ export async function llmComplete(request) {
             continue;
         }
         const provider = providers[modelEntry.provider];
+        const attemptStartedAt = Date.now();
         try {
             const result = await provider.complete({
                 apiModelId: modelEntry.apiModelId,
@@ -124,6 +125,7 @@ export async function llmComplete(request) {
                     fallbackModel: modelName,
                     fallbackProvider: modelEntry.provider,
                     attemptsBeforeSuccess: failedAttempts.length,
+                    ...(request.callSite ? { callSite: request.callSite } : {}),
                 });
             }
             return {
@@ -162,6 +164,12 @@ export async function llmComplete(request) {
                 declined: err instanceof LLMError && err.declined === true,
                 attemptNumber: failedAttempts.length,
                 nextModel: modelsToTry[failedAttempts.length] ?? 'none',
+                // Which caller, and whether it ran out its own deadline: a timeout tail is a
+                // headroom question for that call site, an HTTP error is not (reader task 58b65ec9).
+                ...(request.callSite ? { callSite: request.callSite } : {}),
+                timedOut: err instanceof LLMError && err.timedOut === true,
+                timeoutMs,
+                attemptMs: Date.now() - attemptStartedAt,
             });
         }
     }

package/dist/llm/providers/anthropic.js

@@ -140,6 +140,7 @@ export const anthropicProvider = {
                 provider: 'anthropic',
                 model: request.apiModelId,
                 isRetryable: true,
+                timedOut: err instanceof Error && err.name === 'AbortError',
             });
         }
         finally {

package/dist/llm/providers/gemini.js

@@ -125,6 +125,7 @@ export const geminiProvider = {
                 provider: 'gemini',
                 model: request.apiModelId,
                 isRetryable: true,
+                timedOut: err instanceof Error && err.name === 'AbortError',
             });
         }
         finally {

package/dist/llm/providers/openai.js

@@ -149,6 +149,7 @@ export const openaiProvider = {
                 provider: 'openai',
                 model: request.apiModelId,
                 isRetryable: true,
+                timedOut: err instanceof Error && err.name === 'AbortError',
             });
         }
         finally {

package/dist/llm/types.d.ts

@@ -155,6 +155,8 @@ export declare class LLMError extends Error {
      * not a defect.
      */
     declined: boolean;
+    /** True when the attempt hit its per-provider `timeoutMs` deadline. */
+    timedOut: boolean;
     constructor(opts: {
         message: string;
         provider: ProviderName;
@@ -162,6 +164,7 @@ export declare class LLMError extends Error {
         statusCode?: number;
         isRetryable: boolean;
         declined?: boolean;
+        timedOut?: boolean;
     });
 }
 export interface ProviderAdapter {

package/dist/llm/types.js

@@ -20,6 +20,8 @@ export class LLMError extends Error {
      * not a defect.
      */
     declined;
+    /** True when the attempt hit its per-provider `timeoutMs` deadline. */
+    timedOut;
     constructor(opts) {
         super(opts.message);
         this.name = 'LLMError';
@@ -28,5 +30,6 @@ export class LLMError extends Error {
         this.statusCode = opts.statusCode;
         this.isRetryable = opts.isRetryable;
         this.declined = opts.declined ?? false;
+        this.timedOut = opts.timedOut ?? false;
     }
 }

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.40.0",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",