@pify/shell-background 0.1.0 → 0.1.2

package/README.md

@@ -56,9 +56,13 @@ Put these in `.pi/shell-background.json` (project) or `<agentDir>/shell-backgrou
 
 `autoBackgroundMs` is how long a foreground command may run before it auto-backgrounds; set it to `0` to disable auto-background (explicit `background: true` still works). `PIFY_SHELL_BG_MS` overrides it for one run or in CI. `tailBytes` bounds how much of a job's log a status result shows. Bad values fall back to the defaults with a warning rather than taking the tool down.
 
-## Coexistence
+## Coexistence with @pify/pretty
 
-This package owns the `bash` tool's execution. If you also run another extension that re-registers `bash` (a renderer like `@pify/pretty`, say), whichever loads last wins — install order decides. `@pify/pretty` only changes rendering and leaves execution alone, so the usual advice is to let this package load after it.
+Both this package and `@pify/pretty` re-register `bash`: this one to change its *execution* (async), pretty to change its *rendering* (compact, syntax-highlit). pi's `registerTool` is last-write-wins and gives an extension no way to read or wrap another's registered tool, so the two cannot be merged — whichever loads last wins the whole `bash` tool.
+
+**Load `@pify/shell-background` after `@pify/pretty`.** Async bash is the reason to install this package, so it should own execution; pretty keeps rendering every other tool (`read`, `edit`, `grep`, `write`, `ls`, `find`) — only its `bash`-specific rendering yields, and you still get pi's default bash view here. If pretty loads last instead, *this package's async execution is lost* and bash reverts to blocking — the outcome to avoid.
+
+(A future pi API to compose registered tools would let both apply at once; today none exists.)
 
 ## License
 

package/extensions/shell-background.ts

@@ -47,6 +47,7 @@ import { DEFAULT_SETTINGS, resolveSettings, type ShellBgSettings } from "../src/
 import { backgroundedResult, deliveryMessage, DELIVERY_TYPE } from "../src/pending.ts";
 import { formatResult, formatList, header } from "../src/format.ts";
 import { buildWidgetLines } from "../src/widget.ts";
+import { isFinished } from "../src/types.ts";
 import type { Job } from "../src/types.ts";
 
 type UiContext = ExtensionContext;
@@ -236,6 +237,19 @@ export default function shellBackground(pi: ExtensionAPI) {
 
       if (outcome === "auto") {
         scheduleDelivery(job, settle);
+        // A timeout the caller set still applies once the command is in the
+        // background: schedule the kill for the time it has left so the deadline
+        // the model expects is honoured rather than silently dropped. This timer
+        // deliberately outlives the `finally` below, so it is not in `timers`.
+        if (params.timeout && params.timeout > 0) {
+          const remaining = params.timeout * 1000 - (Date.now() - job.startedAt);
+          const killAt = setTimeout(() => {
+            if (job.status !== "running") return;
+            job.killedByUs = true;
+            killTree(job.pid);
+          }, Math.max(0, remaining));
+          killAt.unref?.();
+        }
         const r = backgroundedResult({
           id: job.id,
           command,
@@ -314,8 +328,13 @@ export default function shellBackground(pi: ExtensionAPI) {
         const known = registry.all().map((j) => j.id).join(", ") || "(none)";
         return { content: [{ type: "text", text: `No job "${id}". Known: ${known}` }], details: {}, isError: true };
       }
-      // Reading marks it collected so it will not also be delivered unasked.
-      job.delivered = 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
+      // delivered here would permanently cancel the promised auto-delivery.
+      if (isFinished(job)) {
+        job.delivered = true;
+        registry.persist(job);
+      }
       return {
         content: [{ type: "text", text: formatResult(job, settings.tailBytes) }],
         details: { id: job.id, status: job.status, exitCode: job.exitCode },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pify/shell-background",
-  "version": "0.1.0",
+  "version": "0.1.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/spawn.ts

@@ -41,6 +41,11 @@ export function spawnToFile(
 ): Spawned {
   // Append so a re-attach or racing read never clips output already written.
   const out = createWriteStream(logPath, { flags: "a" });
+  // 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
+  // not — so swallow it here.
+  out.on("error", () => {});
 
   let child;
   try {