@ian-pascoe/pi-termctrl 0.4.0 → 0.4.1

package/README.md

@@ -92,7 +92,7 @@ another fails and lists the caller's live entries.
 `terminal_stop` stops a running entry (termctrl stop, then `SIGKILL` of the
 Terminal's process group if it is still alive after 3 s) and forgets it. For a
 Terminal it returns the final screen and scrolled-off lines; for a Background
-job, its recent output. When a Terminal had already exited and its screen is
+job, its recent output. When a Terminal's screen is
 unchanged since the agent's last result, the result omits the screen and reports
 `changed: false` with `state` and `exit_code` or `signal`; `scrolled_off` still
 appears when lines scrolled off since that result. Exited entries stay

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ian-pascoe/pi-termctrl",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "private": false,
   "description": "Interactive Terminals, Background jobs, and a /ps panel for Pi.",
   "keywords": [

package/src/termctrl-driver.ts

@@ -36,19 +36,38 @@ async function readPid(pidFile: string): Promise<number | undefined> {
   return undefined;
 }
 
+/**
+ * The requests made to one driver. termctrl answers every request sent before its shutdown request
+ * and none sent after it, and the SDK sends a request while its close is in flight without ever
+ * failing it, so that request would wait forever. The registry closes an idle driver without
+ * waiting, and a tool call may still read one of its exited Terminals, as `terminal_stop` does.
+ * Requests are therefore refused once closing starts, with the SDK's message for a closed driver.
+ */
+class DriverRequests {
+  private closing = false;
+
+  send<T>(request: () => Promise<T>): Promise<T> {
+    return this.closing ? Promise.reject(new Error("termctrl driver is closed")) : request();
+  }
+
+  close(shutdown: () => Promise<void>): Promise<void> {
+    this.closing = true;
+    return shutdown();
+  }
+}
+
 class TermctrlTerminal implements TerminalHandle {
   constructor(
     private readonly session: Session,
+    private readonly requests: DriverRequests,
     private readonly pid: number | undefined,
   ) {}
 
   async snapshot(): Promise<TerminalSnapshot> {
-    const status = await this.session.status();
-    const capture = await this.session.screen.capture({
-      allowIncomplete: true,
-      settleMs: 0,
-      deadlineMs: 0,
-    });
+    const status = await this.requests.send(() => this.session.status());
+    const capture = await this.requests.send(() =>
+      this.session.screen.capture({ allowIncomplete: true, settleMs: 0, deadlineMs: 0 }),
+    );
     return {
       screen: capture.text,
       state: status.state,
@@ -58,19 +77,19 @@ class TermctrlTerminal implements TerminalHandle {
   }
 
   logs(): Promise<string> {
-    return this.session.logs.text();
+    return this.requests.send(() => this.session.logs.text());
   }
 
   type(text: string): Promise<void> {
-    return this.session.keyboard.type(text);
+    return this.requests.send(() => this.session.keyboard.type(text));
   }
 
   press(keys: readonly Key[]): Promise<void> {
-    return this.session.keyboard.sequence(keys);
+    return this.requests.send(() => this.session.keyboard.sequence(keys));
   }
 
   stop(): Promise<void> {
-    return this.session.stop();
+    return this.requests.send(() => this.session.stop());
   }
 
   isAlive(): boolean {
@@ -98,6 +117,8 @@ class TermctrlTerminal implements TerminalHandle {
 }
 
 class TermctrlDriver implements TerminalDriver {
+  private readonly requests = new DriverRequests();
+
   constructor(private readonly control: TerminalControl) {}
 
   async launch(request: TerminalLaunchRequest): Promise<TerminalHandle> {
@@ -105,19 +126,21 @@ class TermctrlDriver implements TerminalDriver {
     await mkdir(directory, { recursive: true });
     const pidFile = join(directory, `${process.pid}-${request.id}.pid`);
     try {
-      const session = await this.control.launch({
-        command: ["/bin/sh", "-c", PID_WRAPPER, "pi-termctrl", pidFile, ...request.command],
-        cwd: request.cwd,
-        viewport: request.viewport,
-      });
-      return new TermctrlTerminal(session, await readPid(pidFile));
+      const session = await this.requests.send(() =>
+        this.control.launch({
+          command: ["/bin/sh", "-c", PID_WRAPPER, "pi-termctrl", pidFile, ...request.command],
+          cwd: request.cwd,
+          viewport: request.viewport,
+        }),
+      );
+      return new TermctrlTerminal(session, this.requests, await readPid(pidFile));
     } finally {
       await rm(pidFile, { force: true });
     }
   }
 
   close(): Promise<void> {
-    return this.control.close();
+    return this.requests.close(() => this.control.close());
   }
 }
 

package/src/terminal-tools.ts

@@ -140,7 +140,7 @@ const StopResultSchema = Type.Object({
   screen: Type.Optional(
     Type.String({
       description:
-        "Terminal only: the final screen; omitted for an exited Terminal whose screen is unchanged since your previous result",
+        "Terminal only: the final screen; omitted when unchanged since your previous result",
     }),
   ),
   scrolled_off: Type.Optional(
@@ -815,10 +815,11 @@ export function createTerminalStopTool(registry: TermctrlRegistry) {
       const parts = [header];
       if (entry.kind === "terminal") {
         const screen = entry.finalScreen ?? "";
-        // An exited Terminal's screen the agent already saw is not repeated.
-        const repeated = !wasRunning && previousScreen === screen;
+        const changed = previousScreen !== screen;
+        // A screen the agent already saw is not repeated, whether the Terminal was running or exited.
+        const repeated = !changed;
         const output = await fitOutput(registry, entry, repeated ? "" : screen, scrolled);
-        result.changed = previousScreen !== screen;
+        result.changed = changed;
         if (!repeated) result.screen = output.screen;
         if (!repeated || output.scrolledOff !== "") result.scrolled_off = output.scrolledOff;
         if (output.gap) result.output_missing = true;