@clawdbuilder/jig-bedrock 0.1.1 → 0.1.2

package/README.md

@@ -154,7 +154,16 @@ mode bits), and the no-browser fallback is the WSL-only `bin/windows-browser` sh
 | `/bedrock-doctor`         | Probe Node, AWS CLI, bash, jq and the optional usage program; it does not call AWS |
 
 The footer and `/bedrock-usage` read an executable named `usage` in `usageDir`; it is called with `--daily`,
-`--weekly` or `--monthly` and `--output json`, and prints the spend as JSON.
+`--weekly` or `--monthly` and `--output json`, and prints the spend as JSON. It receives `AWS_PROFILE` and
+`BEDROCK_REGIONS` in its environment.
+
+If your usage CLI's own command is `usage-cli`, put this two-line wrapper at
+`~/.local/share/usage-tool/usage` and make it executable:
+
+```sh
+#!/bin/sh
+exec usage-cli usage "$@"
+```
 
 ## Tests
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clawdbuilder/jig-bedrock",
-    "version": "0.1.1",
+    "version": "0.1.2",
     "description": "Claude on AWS Bedrock for Pi: inference-profile discovery, the Messages route with cache-friendly tools, Converse fallback, SSO repair and a budget footer.",
     "type": "module",
     "license": "MIT",

package/src/sso-check.ts

@@ -100,12 +100,18 @@ export async function checkSso(
 ): Promise<SsoState> {
     // The fast path: a cached token that stays valid needs no network check and no SDK.
     if (cachedTokenFresh(profile, deps)) return "ok";
-    const limit = AbortSignal.timeout(deps.timeoutMs);
+    // `AbortSignal.timeout` uses an unreferenced timer. With a stalled SDK and nothing else in the event loop, the process
+    // would exit before the check could return an error. A referenced timer keeps the check alive for its own timeout.
+    const controller = new AbortController();
+    const limit = controller.signal;
+    const timer = setTimeout(() => controller.abort(), deps.timeoutMs);
     try {
         // The SDK's answer is dropped: only whether it resolved matters.
         await until(deps.credentialProvider()({ profile })(), signal ? AbortSignal.any([signal, limit]) : limit);
         return "ok";
     } catch (error) {
         return classify(error);
+    } finally {
+        clearTimeout(timer);
     }
 }

package/src/statistics.ts

@@ -250,24 +250,20 @@ export function createStatistics(
             previous = load(period);
         if (!options.force && previous && !previous.stale) return previous;
         try {
-            const output = await runner(
-                usageExecutable(config),
-                ["usage", `--${period}`, "--output", "json", "--aws-profile", config.profile],
-                {
-                    timeout: 120_000,
-                    maxBuffer: 2_097_152,
-                    signal: options.signal,
-                    env: {
-                        ...process.env,
-                        BEDROCK_REGIONS: config.regions.join(","),
-                        AWS_PROFILE: config.profile,
-                        AWS_CLI_AUTO_PROMPT: "off",
-                        AWS_PAGER: "",
-                        NO_COLOR: "1",
-                        PAT_SKIP_UPDATE_CHECK: "1",
-                    },
+            const output = await runner(usageExecutable(config), [`--${period}`, "--output", "json"], {
+                timeout: 120_000,
+                maxBuffer: 2_097_152,
+                signal: options.signal,
+                env: {
+                    ...process.env,
+                    BEDROCK_REGIONS: config.regions.join(","),
+                    AWS_PROFILE: config.profile,
+                    AWS_CLI_AUTO_PROMPT: "off",
+                    AWS_PAGER: "",
+                    NO_COLOR: "1",
+                    PAT_SKIP_UPDATE_CHECK: "1",
                 },
-            );
+            });
             if (options.signal?.aborted) throw new UsageError("cancelled");
             const observedAt = now();
             // Legacy reports have no explicit range, so a UTC rollover cannot be safely relabelled.

package/src/usage.ts

@@ -113,8 +113,9 @@ export const runUsage: UsageRunner = (program, args, options) =>
         );
         child.on("close", (code) => finish(code === 0 ? undefined : new UsageError(classify(stderr))));
         options.signal?.addEventListener("abort", abort, { once: true });
+        // A referenced timer keeps a stalled program's timeout alive when nothing else holds the event loop. It is
+        // cleared in finish(), so a program that answers does not delay exit.
         timer = setTimeout(() => finish(new UsageError("timeout")), options.timeout);
-        timer.unref();
         if (options.signal?.aborted) abort();
     });
 export const usageExecutable = (config: ResolvedConfig): string =>