@pify/shell-background 0.4.0 → 0.4.2

package/README.md

@@ -34,7 +34,7 @@ shell_kill { id: "bg-2" }                # stop it and its whole process tree
 
 ## Delivery, and the headless caveat
 
-When a backgrounded command finishes in an **interactive** session, its result is pushed into the conversation as the next turn — you do not have to poll. Under headless `pi -p` there is nothing to deliver into (the session tears down when the prompt resolves), so **auto-background is disabled there** and only explicit `background: true` applies; collect it within the same turn with `shell_status { id, wait: N }`, which blocks (up to `N` seconds, 0–300) until the command finishes rather than returning immediately. This is the same delivery rule the rest of the suite lives by.
+When a backgrounded command finishes in an **interactive** session, its result is pushed into the conversation as the next turn — you do not have to poll. Under headless `pi -p` there is nothing to deliver into (the session tears down when the prompt resolves), so **auto-background is disabled there** and only explicit `background: true` applies; collect it within the same turn with `shell_status { id, wait: N }`, which blocks (up to `N` seconds, 0–300) until the command finishes rather than returning immediately. This is the same delivery rule the rest of the suite lives by. A finish that a `shell_status` wait returns is collected there and not delivered a second time, so the model never spends a turn acknowledging a result it has just reported.
 
 ## How it works
 

package/extensions/shell-background.ts

@@ -229,6 +229,18 @@ export default function shellBackground(pi: ExtensionAPI) {
     );
   }
 
+  /**
+   * Jobs a shell_status wait is blocking on, by id. Seen on pi 1.0.4 with the
+   * TUI captured: a foreground command auto-backgrounds at 30s, the model
+   * waits on it with shell_status, the exit handler delivers the finish as a
+   * follow-up in the same instant the wait returns it, and the model spends a
+   * whole extra turn acknowledging a result it had just reported. While a
+   * wait is active the finish is returned there and marked collected; the
+   * delivery path stands down.
+   */
+  const waiters = new Map<string, number>();
+  const awaited = (job: Job): boolean => (waiters.get(job.id) ?? 0) > 0;
+
   /** Deliver a finished background job into the conversation, once. */
   function scheduleDelivery(job: Job, exit: Promise<unknown>): void {
     exit
@@ -241,7 +253,7 @@ export default function shellBackground(pi: ExtensionAPI) {
           registry?.persist(job);
           return;
         }
-        if (job.delivered) return;
+        if (job.delivered || awaited(job)) return;
         job.delivered = true;
         registry?.persist(job);
         deliver(job);
@@ -522,7 +534,22 @@ export default function shellBackground(pi: ExtensionAPI) {
       const waitSec = Number.isFinite(params.wait) ? Math.min(300, Math.max(0, Math.floor(params.wait as number))) : 0;
       if (waitSec > 0 && job.status === "running") {
         const deadline = Date.now() + waitSec * 1000;
-        while (job.status === "running" && Date.now() < deadline && !sig?.aborted) await sleep(250);
+        waiters.set(job.id, (waiters.get(job.id) ?? 0) + 1);
+        try {
+          while (job.status === "running" && Date.now() < deadline && !sig?.aborted) await sleep(250);
+        } finally {
+          waiters.set(job.id, Math.max(0, (waiters.get(job.id) ?? 1) - 1));
+        }
+      }
+      if (sig?.aborted) {
+        // The model never sees an aborted tool result. If the job finished
+        // while this wait held the delivery path back, deliver it now.
+        if (isFinished(job) && !job.delivered) {
+          job.delivered = true;
+          registry.persist(job);
+          deliver(job);
+        }
+        return { content: [{ type: "text", text: `shell_status ${job.id}: wait aborted` }], details: { id: job.id }, isError: true };
       }
       // Reading a finished job marks it collected so it will not also be
       // delivered unasked. A still-running poll must never do this: setting
@@ -614,7 +641,7 @@ export default function shellBackground(pi: ExtensionAPI) {
           }
         }
         if (job.status === "running") anyRunning = true;
-        else if (!job.delivered) {
+        else if (!job.delivered && !awaited(job)) {
           job.delivered = true;
           registry.persist(job);
           deliver(job);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pify/shell-background",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Long-running bash goes async: background: true launches detached, and any command still running after 30s auto-backgrounds and delivers its result when it finishes",
   "keywords": [
     "pi-package",

package/src/format.ts

@@ -17,12 +17,11 @@ function duration(job: Job): string {
   return secs(Math.max(0, end - job.startedAt));
 }
 
-/** `[bg-1 · done · exit 0 · 4.2s]` — the one-line header every result carries. */
+/** `[bg-1 · done · exit 0 · 4.2s]` — the one-line header every result carries. A running job has no verdict yet: `[bg-1 · running · 13.2s]`. */
 export function header(job: Job): string {
+  if (job.status === "running") return `[${job.id} · running · ${duration(job)}]`;
   const verdict =
-    job.status === "running"
-      ? "running"
-      : job.status === "orphaned"
+    job.status === "orphaned"
         ? "orphaned (another session)"
         : job.signal
           ? `signal ${job.signal}`

package/src/registry.ts

@@ -44,7 +44,8 @@ export class JobRegistry {
 
   constructor(baseDir: string) {
     this.baseDir = baseDir;
-    mkdirSync(join(baseDir, "logs"), { recursive: true });
+    // Logs and sidecars carry command output and cwd paths: the user's eyes only.
+    mkdirSync(join(baseDir, "logs"), { recursive: true, mode: 0o700 });
   }
 
   /** The directory this registry's sidecars and logs live under. */
@@ -93,7 +94,7 @@ export class JobRegistry {
     try {
       const file = join(this.baseDir, `${job.id}.json`);
       const tmp = `${file}.${process.pid}.tmp`;
-      writeFileSync(tmp, JSON.stringify(job));
+      writeFileSync(tmp, JSON.stringify(job), { mode: 0o600 });
       renameSync(tmp, file);
     } catch {
       // A registry we cannot persist still works for the live session.

package/src/spawn.ts

@@ -40,7 +40,9 @@ export function spawnToFile(
   logPath: string,
 ): Spawned {
   // Append so a re-attach or racing read never clips output already written.
-  const out = createWriteStream(logPath, { flags: "a" });
+  // Command output can carry private data, so the log is readable by the user
+  // only (pi 1.0.3 does the same for its own output files; a no-op on Windows).
+  const out = createWriteStream(logPath, { flags: "a", mode: 0o600 });
   // A write stream with no 'error' listener turns any disk error (ENOSPC,
   // EACCES) or a stray write-after-end into an uncaught exception that takes the
   // whole pi host down. Losing a log line is survivable; crashing the host is