@thurstonsand/pi-agent-switchboard 0.3.0 → 0.4.0

package/index.js

@@ -1,10 +1,14 @@
 // packages/pi/src/index.ts
 import { execFile } from "node:child_process";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, writeFileSync } from "node:fs";
+import { dirname as dirname3, join as join2 } from "node:path";
 import { promisify } from "node:util";
+import { Text } from "@earendil-works/pi-tui";
 
 // packages/shared/src/index.ts
 import { execFileSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { existsSync as existsSync2, readFileSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname as dirname2, join } from "node:path";
 
 // packages/shared/src/db.ts
@@ -70,7 +74,20 @@ class Db {
 }
 
 // packages/shared/src/index.ts
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 3;
+function configDir() {
+  return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "agent-switchboard");
+}
+function operatorDir() {
+  if (physicalOperatorDir)
+    return physicalOperatorDir;
+  const dir = join(configDir(), "operator");
+  if (!existsSync2(dir))
+    return dir;
+  physicalOperatorDir = realpathSync(dir);
+  return physicalOperatorDir;
+}
+var physicalOperatorDir;
 function bootId() {
   if (process.platform === "darwin")
     return execFileSync("/usr/sbin/sysctl", ["-n", "kern.bootsessionuuid"], { encoding: "utf8" }).trim();
@@ -156,6 +173,7 @@ function hostOfTranscript(db, proc, transcript) {
   return liveHost(db.get("SELECT r.tmux_session, r.boot_id, r.pid FROM runtimes r JOIN sessions s USING (session_id) WHERE s.transcript = ? AND r.tmux_session != ?", transcript, proc.launch.tmuxSession));
 }
 function src_default(pi) {
+  pi.on("project_trust", (event) => ({ trusted: event.cwd === operatorDir() ? "yes" : "undecided" }));
   const claimed = claim();
   if (!claimed)
     return;
@@ -211,8 +229,24 @@ function src_default(pi) {
     ctx.ui.notify(`swb: that session is already open in another pi (${host})`, "error");
     return { cancel: true };
   });
-  pi.on("session_start", (_event, ctx) => {
+  const draftPath = (id) => join2(dirname3(proc.launch.db), "drafts", id);
+  const restoreDraft = (ctx, id) => {
+    let draft;
+    try {
+      draft = readFileSync2(draftPath(id), "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return;
+      throw error;
+    }
+    if (!ctx.ui.getEditorText())
+      ctx.ui.setEditorText(draft);
+    rmSync(draftPath(id));
+  };
+  pi.on("session_start", (event, ctx) => {
     current = ctx.sessionManager.getSessionId();
+    if (event.reason !== "reload")
+      restoreDraft(ctx, current);
     proc.attention.clear();
     writeFor(ctx, (db, id) => {
       const host = hostOfSession(db, proc, id);
@@ -287,22 +321,46 @@ function src_default(pi) {
     }
   });
   pi.registerTool({
-    name: "swb_archive",
-    label: "Archive session",
-    description: "Archive this session in Agent Switchboard. It leaves the user's roster of open sessions, and pi quits as soon as this turn ends. The user can restore it with `swb unarchive <id>`.",
-    promptSnippet: "Archive this session when the user asks",
+    name: "swb_update_session",
+    label: "Update session",
+    description: "Archive or unarchive a session. Omit session to update the current session.",
+    promptSnippet: "Archive or unarchive a session",
     promptGuidelines: [
-      "Use swb_archive only when the user asks to archive this session; never archive on your own initiative.",
-      "Call swb_archive as the last action of the turn, then end with a brief final message: pi quits once the turn ends."
+      "Archive only when the user asks, or when you started that session and have driven it to completion.",
+      "Archiving the current session will quit it when the turn ends: call it last, then end with a brief final message.",
+      "Archiving another session fails while it is mid-turn. Unarchiving doesn't restart it; session_send_message wakes it."
     ],
-    parameters: Type.Object({}),
-    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-      if (!markArchived(ctx)) {
-        throw new Error(proc.failure ? `swb: not recording: ${proc.failure}` : "swb: no session recorded yet");
+    parameters: Type.Object({
+      session: Type.Optional(Type.String({ description: "Session id; omit for the current session" })),
+      archived: Type.Boolean()
+    }),
+    renderCall(args, theme) {
+      const target = !args.session || args.session === current ? "This session" : connect().get("SELECT title FROM sessions WHERE session_id = ?", args.session)?.title ?? args.session;
+      return new Text(`${theme.fg("toolTitle", theme.bold(args.archived ? "Archive" : "Unarchive"))} · ${theme.fg("accent", target)}`, 0, 0);
+    },
+    renderResult(result, _options, theme, context) {
+      const output = result.content.find((item) => item.type === "text")?.text ?? "";
+      return new Text(context.isError ? theme.fg("error", output) : "", 0, 0);
+    },
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      const self = ctx.sessionManager.getSessionId();
+      if (!params.session || params.session === self) {
+        if (!params.archived)
+          throw new Error("this session is already open");
+        if (!markArchived(ctx)) {
+          throw new Error(proc.failure ? `swb: not recording: ${proc.failure}` : "swb: no session recorded yet");
+        }
+        ctx.shutdown();
+        return { content: [{ type: "text", text: "Archived. pi quits when this turn ends." }], details: undefined };
+      }
+      try {
+        await run(proc.launch.bin, [params.archived ? "archive" : "unarchive", params.session], { timeout: 15000 });
+      } catch (error) {
+        const { stderr, message } = error;
+        throw new Error(stderr?.trim() || message);
       }
-      ctx.shutdown();
       return {
-        content: [{ type: "text", text: "Archived. pi quits when this turn ends." }],
+        content: [{ type: "text", text: params.archived ? "Archived." : "Unarchived. It stays dormant until messaged." }],
         details: undefined
       };
     }
@@ -310,6 +368,12 @@ function src_default(pi) {
   pi.on("session_shutdown", (event, ctx) => {
     if (event.reason !== "quit")
       return;
+    const draft = ctx.ui.getEditorText();
+    if (draft.trim()) {
+      const path = draftPath(ctx.sessionManager.getSessionId());
+      mkdirSync2(dirname3(path), { recursive: true, mode: 448 });
+      writeFileSync(path, draft, { mode: 384 });
+    }
     writeFor(ctx, (db) => db.run("DELETE FROM runtimes WHERE tmux_session = ?", proc.launch.tmuxSession));
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@thurstonsand/pi-agent-switchboard",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"type": "module",
 	"description": "Records managed pi sessions for Agent Switchboard (swb)",
 	"license": "MIT",
@@ -18,6 +18,7 @@
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",
+		"@earendil-works/pi-tui": "*",
 		"typebox": "*"
 	}
 }