@thurstonsand/pi-agent-switchboard 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Thurston Sandberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/index.js

@@ -0,0 +1,286 @@
+// packages/shared/src/index.ts
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { dirname as dirname2, join } from "node:path";
+
+// packages/shared/src/db.ts
+import { closeSync, existsSync, mkdirSync, openSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname } from "node:path";
+var require2 = createRequire(import.meta.url);
+function connect(path) {
+  if (process.versions.bun) {
+    const { Database } = require2("bun:sqlite");
+    return new Database(path, { strict: false });
+  }
+  const { DatabaseSync } = require2("node:sqlite");
+  return new DatabaseSync(path);
+}
+
+class Db {
+  path;
+  #driver;
+  constructor(path, { create }) {
+    this.path = path;
+    if (create) {
+      mkdirSync(dirname(path), { recursive: true, mode: 448 });
+      closeSync(openSync(path, "a", 384));
+    } else if (!existsSync(path)) {
+      throw new Error(`no db at ${path}`);
+    }
+    this.#driver = connect(path);
+    this.#driver.exec("PRAGMA journal_mode = WAL; PRAGMA synchronous = FULL; PRAGMA busy_timeout = 5000; PRAGMA foreign_keys = ON;");
+  }
+  get(sql, ...params) {
+    return this.#driver.prepare(sql).get(...params) ?? undefined;
+  }
+  all(sql, ...params) {
+    return this.#driver.prepare(sql).all(...params);
+  }
+  run(sql, ...params) {
+    this.#driver.prepare(sql).run(...params);
+  }
+  exec(sql) {
+    this.#driver.exec(sql);
+  }
+  userVersion() {
+    return Number(this.get("PRAGMA user_version")?.user_version);
+  }
+  dataVersion() {
+    return Number(this.get("PRAGMA data_version")?.data_version);
+  }
+  tx(body) {
+    this.#driver.exec("BEGIN IMMEDIATE");
+    try {
+      const result = body();
+      this.#driver.exec("COMMIT");
+      return result;
+    } catch (error) {
+      this.#driver.exec("ROLLBACK");
+      throw error;
+    }
+  }
+  close() {
+    this.#driver.close();
+  }
+}
+
+// packages/shared/src/index.ts
+var SCHEMA_VERSION = 1;
+function bootId() {
+  if (process.platform === "darwin")
+    return execFileSync("/usr/sbin/sysctl", ["-n", "kern.bootsessionuuid"], { encoding: "utf8" }).trim();
+  return readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function git(cwd, ...args) {
+  try {
+    return execFileSync("git", ["-C", cwd, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+function projectRoot(cwd) {
+  const common = git(cwd, "rev-parse", "--path-format=absolute", "--git-common-dir");
+  return common ? dirname2(common) : cwd;
+}
+function branch(cwd) {
+  const name = git(cwd, "rev-parse", "--abbrev-ref", "HEAD");
+  return name === "HEAD" ? git(cwd, "rev-parse", "--short", "HEAD") : name;
+}
+
+// packages/pi/src/index.ts
+import { Type } from "typebox";
+var KEY = Symbol.for("agent-switchboard.recorder");
+var store = globalThis;
+function claim() {
+  const env = process.env;
+  if (env.SWB_MANAGED === "1" && env.SWB_DB && env.SWB_TMUX_SESSION) {
+    store[KEY] = { launch: Object.freeze({ db: env.SWB_DB, tmuxSession: env.SWB_TMUX_SESSION }), attention: new Set };
+  }
+  delete env.SWB_MANAGED;
+  delete env.SWB_DB;
+  delete env.SWB_TMUX_SESSION;
+  return store[KEY];
+}
+function liveHost(row) {
+  if (row && row.boot_id === bootId() && pidAlive(row.pid))
+    return row.tmux_session;
+  return;
+}
+function hostOfSession(db, proc, sessionId) {
+  return liveHost(db.get("SELECT tmux_session, boot_id, pid FROM runtimes WHERE session_id = ? AND tmux_session != ?", sessionId, proc.launch.tmuxSession));
+}
+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) {
+  const claimed = claim();
+  if (!claimed)
+    return;
+  const proc = claimed;
+  let ui;
+  const showFailure = () => ui?.setStatus("swb", ui.theme.fg("error", `swb: not recording: ${proc.failure}`));
+  const connect = () => {
+    proc.db ??= new Db(proc.launch.db, { create: false });
+    return proc.db;
+  };
+  const fail = (error) => {
+    proc.failure = error instanceof Error ? error.message : String(error);
+    showFailure();
+    ui?.notify(`swb: not recording: ${proc.failure}`, "error");
+  };
+  const write = (sessionId, body) => {
+    if (proc.failure) {
+      showFailure();
+      return;
+    }
+    try {
+      const db = connect();
+      db.tx(() => {
+        const version = db.userVersion();
+        if (version !== SCHEMA_VERSION)
+          throw new Error(`db schema is v${version}, this recorder writes v${SCHEMA_VERSION}`);
+        body(db, sessionId);
+      });
+    } catch (error) {
+      fail(error);
+    }
+  };
+  const writeFor = (ctx, body) => {
+    ui = ctx.ui;
+    write(ctx.sessionManager.getSessionId(), body);
+  };
+  let current;
+  pi.on("session_before_switch", (event, ctx) => {
+    if (event.reason !== "resume" || !event.targetSessionFile || proc.failure)
+      return;
+    ui = ctx.ui;
+    let host;
+    try {
+      host = hostOfTranscript(connect(), proc, event.targetSessionFile);
+    } catch (error) {
+      fail(error);
+      return;
+    }
+    if (!host)
+      return;
+    ctx.ui.notify(`swb: that session is already open in another pi (${host})`, "error");
+    return { cancel: true };
+  });
+  pi.on("session_start", (_event, ctx) => {
+    current = ctx.sessionManager.getSessionId();
+    proc.attention.clear();
+    writeFor(ctx, (db, id) => {
+      const host = hostOfSession(db, proc, id);
+      if (host)
+        throw new Error(`session ${id} is already open in another pi (${host})`);
+      db.run("DELETE FROM runtimes WHERE session_id = ? AND tmux_session != ?", id, proc.launch.tmuxSession);
+      db.run(`INSERT INTO runtimes (tmux_session, session_id, cwd, project_root, boot_id, pid, started_at) VALUES (?, ?, ?, ?, ?, ?, ?)
+				 ON CONFLICT (tmux_session) DO UPDATE SET session_id = excluded.session_id, cwd = excluded.cwd,
+				   project_root = excluded.project_root, boot_id = excluded.boot_id, pid = excluded.pid`, proc.launch.tmuxSession, id, ctx.cwd, projectRoot(ctx.cwd), bootId(), process.pid, Date.now());
+      const transcript = ctx.sessionManager.getSessionFile();
+      if (!transcript)
+        throw new Error("pi is running without a session file");
+      db.run("UPDATE sessions SET phase = 'idle', cwd = ?, project_root = ?, branch = ?, transcript = ? WHERE session_id = ?", ctx.cwd, projectRoot(ctx.cwd), branch(ctx.cwd), transcript, id);
+    });
+  });
+  pi.on("message_start", (event, ctx) => {
+    if (event.message.role !== "user")
+      return;
+    writeFor(ctx, (db, id) => {
+      const transcript = ctx.sessionManager.getSessionFile();
+      if (!transcript)
+        throw new Error("pi is running without a session file");
+      const now = Date.now();
+      db.run(`INSERT INTO sessions (session_id, tool, cwd, project_root, transcript, title, branch, phase, created_at, last_prompt_at)
+				 VALUES (?, 'pi', ?, ?, ?, ?, ?, 'working', ?, ?)
+				 ON CONFLICT (session_id) DO UPDATE SET phase = 'working', last_prompt_at = excluded.last_prompt_at`, id, ctx.cwd, projectRoot(ctx.cwd), transcript, ctx.sessionManager.getSessionName() ?? null, branch(ctx.cwd), now, now);
+    });
+  });
+  pi.on("agent_start", (_event, ctx) => {
+    writeFor(ctx, (db, id) => db.run("UPDATE sessions SET phase = 'working' WHERE session_id = ?", id));
+  });
+  const attention = (open) => (data) => {
+    const attentionId = data.attentionId;
+    if (typeof attentionId !== "string" || !current)
+      return;
+    if (open)
+      proc.attention.add(attentionId);
+    else
+      proc.attention.delete(attentionId);
+    const phase = proc.attention.size > 0 ? "blocked" : "working";
+    write(current, (db, id) => db.run("UPDATE sessions SET phase = ? WHERE session_id = ? AND phase != 'idle'", phase, id));
+  };
+  pi.events.on("glimpseui:attention:request", attention(true));
+  pi.events.on("glimpseui:attention:resolve", attention(false));
+  pi.on("agent_settled", (_event, ctx) => {
+    proc.attention.clear();
+    writeFor(ctx, (db, id) => {
+      db.run("UPDATE sessions SET phase = 'idle', last_settled_at = ?, cwd = ?, project_root = ?, branch = ?, title = ? WHERE session_id = ?", Date.now(), ctx.cwd, projectRoot(ctx.cwd), branch(ctx.cwd), ctx.sessionManager.getSessionName() ?? null, id);
+      db.run("UPDATE runtimes SET cwd = ?, project_root = ? WHERE tmux_session = ?", ctx.cwd, projectRoot(ctx.cwd), proc.launch.tmuxSession);
+    });
+  });
+  pi.on("session_info_changed", (event, ctx) => {
+    writeFor(ctx, (db, id) => db.run("UPDATE sessions SET title = ? WHERE session_id = ?", event.name ?? null, id));
+  });
+  const markArchived = (ctx) => {
+    let archived = false;
+    writeFor(ctx, (db, id) => {
+      if (!db.get("SELECT 1 FROM sessions WHERE session_id = ?", id))
+        return;
+      db.run("INSERT INTO marks (session_id, archived_at) VALUES (?, ?) ON CONFLICT (session_id) DO UPDATE SET archived_at = excluded.archived_at", id, Date.now());
+      archived = true;
+    });
+    return archived;
+  };
+  pi.registerCommand("archive", {
+    description: "Archive this session in swb and quit",
+    handler: async (_args, ctx) => {
+      if (!ctx.isIdle()) {
+        ctx.ui.notify("swb: turn running: wait for it to complete", "error");
+        return;
+      }
+      if (markArchived(ctx))
+        ctx.shutdown();
+      else if (!proc.failure)
+        ctx.ui.notify("swb: nothing to archive before the first prompt", "error");
+    }
+  });
+  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",
+    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."
+    ],
+    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");
+      }
+      ctx.shutdown();
+      return {
+        content: [{ type: "text", text: "Archived. pi quits when this turn ends." }],
+        details: undefined
+      };
+    }
+  });
+  pi.on("session_shutdown", (event, ctx) => {
+    if (event.reason !== "quit")
+      return;
+    writeFor(ctx, (db) => db.run("DELETE FROM runtimes WHERE tmux_session = ?", proc.launch.tmuxSession));
+  });
+}
+export {
+  src_default as default
+};

package/package.json

@@ -1,6 +1,23 @@
 {
-  "name": "@thurstonsand/pi-agent-switchboard",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@thurstonsand/pi-agent-switchboard",
+	"version": "0.1.0",
+	"type": "module",
+	"description": "Records managed pi sessions for Agent Switchboard (swb)",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/thurstonsand/agent-switchboard.git"
+	},
+	"keywords": [
+		"pi-package"
+	],
+	"pi": {
+		"extensions": [
+			"./index.js"
+		]
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*",
+		"typebox": "*"
+	}
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.