@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/src/pi-intercom/bridge.ts

@@ -6,25 +6,15 @@ import { TLSSocket } from "node:tls";
 import { randomUUID } from "node:crypto";
 import { getBrokerSocketPath } from "./broker/paths.ts";
 import { loadConfig, sameListener, type Config, type Identity } from "./bridge-config.ts";
-import { ASK_TIMEOUT, Fault, fingerprint, log } from "./bridge-protocol.ts";
+import { Fault, fingerprint, log } from "./bridge-protocol.ts";
 import { Session } from "./bridge-session.ts";
 import { operationFor, routeFor } from "./bridge-routes.ts";
 import { reply, replyFault } from "./bridge-http.ts";
-import { sameIdentity } from "./bridge-launch.ts";
-import { BridgeOperations } from "./bridge-operations.ts";
-import { authenticatedCertificateChain } from "./native-control-auth.ts";
 import { PersistentPresence } from "./bridge-presence.ts";
 import { WakeDeliveries } from "./bridge-wake.ts";
 import { spawnBrokerIfNeeded } from "./broker/spawn.ts";
 
 const MAX_CONNECTIONS = 128;
-const LONG_ROUTES = new Set([
-  "POST /v1/start",
-  "POST /v1/spawn",
-  "POST /v1/resume",
-  "GET /v1/transcript",
-  "POST /v1/transcript",
-]);
 
 function validCertificateDates(starts: number, expires: number): boolean {
   return (
@@ -46,7 +36,6 @@ class Bridge {
   private readonly configPath: string;
   private readonly sessions = new Map<string, Session>();
   private readonly losses = new Map<string, number>();
-  private readonly operations: BridgeOperations;
   private readonly sockets = new Set<Socket>();
   private readonly connections = new Map<TLSSocket, Connection>();
   private readonly server: Server;
@@ -58,7 +47,6 @@ class Bridge {
   constructor(config: Config, configPath: string) {
     this.config = config;
     this.configPath = configPath;
-    this.operations = new BridgeOperations(config.stateDir);
     this.deliveries = new WakeDeliveries(config.stateDir, (identity) => this.allowed(identity));
     if (config.stateDir !== undefined) {
       this.presence = new PersistentPresence({
@@ -137,8 +125,9 @@ class Bridge {
     const current = this.config.clients.get(identity.fingerprint256);
     return (
       !this.stopping &&
-      sameIdentity(identity, current) &&
-      JSON.stringify(identity.wake) === JSON.stringify(current?.wake)
+      current?.name === identity.name &&
+      current.cwd === identity.cwd &&
+      JSON.stringify(identity.wake) === JSON.stringify(current.wake)
     );
   }
   private lost(fp: string, count = 1): void {
@@ -257,14 +246,10 @@ class Bridge {
       }
       this.config = next;
       this.revokeRemoved();
-      this.operations.revoke(next.clients).catch(() => log("launch_cleanup", { result: "failed" }));
       log("allowlist_reloaded", { result: "accepted", clients: next.clients.size });
     } catch {
       this.config = { ...this.config, clients: new Map() };
       this.deliveries.reload();
-      this.operations
-        .revoke(this.config.clients)
-        .catch(() => log("launch_cleanup", { result: "failed" }));
       for (const session of this.sessions.values()) {
         session.close(
           new Fault(
@@ -327,7 +312,6 @@ class Bridge {
     await Promise.all([
       ...this.handlers,
       ...sessions.map((session) => session.settled()),
-      this.operations.shutdown(),
       this.presence?.stop(),
       this.deliveries.stop(),
     ]);
@@ -336,7 +320,6 @@ class Bridge {
   private admission(req: IncomingMessage): {
     readonly identity: Identity;
     readonly expires: number;
-    readonly certificate: string;
   } {
     const socket = req.socket;
     const connection = socket instanceof TLSSocket ? this.connections.get(socket) : undefined;
@@ -358,7 +341,6 @@ class Bridge {
     return {
       identity,
       expires: connection.expires,
-      certificate: authenticatedCertificateChain(socket),
     };
   }
   private async handle(req: IncomingMessage, res: ServerResponse): Promise<void> {
@@ -395,7 +377,7 @@ class Bridge {
       );
     };
     try {
-      const { identity, expires, certificate } = this.admission(req);
+      const { identity, expires } = this.admission(req);
       const route = routeFor(req);
       readOnlyInbox = route === "GET /v1/inbox";
       session = this.session(identity, expires);
@@ -403,19 +385,11 @@ class Bridge {
       const signal = controller.signal;
       req.once("aborted", abort);
       res.once("close", onClose);
-      const duration = route === "POST /v1/ask" ? ASK_TIMEOUT + 15000 : 15000;
-      setDeadline(LONG_ROUTES.has(route) ? 75000 : duration);
+      setDeadline(15000);
       const operation = await operationFor(req, route, signal);
-      if (operation.route === "POST /v1/ask") {
-        setDeadline(operation.timeoutMs + 15000);
-      } else if (operation.route === "GET /v1/transcript") {
-        setDeadline(75000);
-      }
-      const data = await this.operations.execute(operation, session, {
+      const data = await session.execute(operation, {
         signal,
         requestId,
-        expires,
-        certificate,
         onPeer: (id) => {
           peer = id;
         },
@@ -457,9 +431,12 @@ function main(): void {
   try {
     const path = resolve(args[1]);
     new Bridge(loadConfig(path), path).start();
-  } catch {
+  } catch (error) {
+    if (error instanceof Fault) {
+      process.stderr.write(`${error.message}\n`);
+    }
     process.stderr.write(
-      "Bridge startup failed: check config schema, file ownership/mode 0600, absolute TLS/cwd paths, TLS credentials, stateDir (owned 0700 directory), and launch policy (0700 sessionDir, Pi packageRoot, extension paths).\n",
+      "Bridge startup failed: check config schema, file ownership/mode 0600, absolute TLS/cwd paths, TLS credentials, and stateDir (owned 0700 directory).\n",
     );
     process.exitCode = 1;
   }

package/src/pi-intercom/broker/broker.ts

@@ -1,14 +1,17 @@
 import net from "net";
-import { chmodSync, writeFileSync, unlinkSync, mkdirSync } from "fs";
+import { chmodSync, writeFileSync, unlinkSync } from "fs";
 import { join } from "path";
 import { randomUUID } from "crypto";
-import { getPiAgentDir } from "../agent-dir.ts";
-import { writeMessage, createMessageReader, validateIntercomMessageSize } from "./framing.ts";
-import { prepareBrokerSocketPath } from "./paths.ts";
+import { writeMessage, validateIntercomMessageSize } from "./framing.ts";
+import { getBrokerRuntimeDir, prepareBrokerSocketPath } from "./paths.ts";
 import { brokerPidRecord } from "./pid.ts";
+import { assertBrokerCanStart } from "./spawn.ts";
+import { LastMessageRelay } from "./last.ts";
+import { canSeeSession, findSessions } from "./targets.ts";
+import { acceptBrokerConnection, registeredSessionInfo } from "./server-connection.ts";
+import { guardedDeliveryError } from "./guard.ts";
 import {
   compactTopicMessage,
-  isSessionRegistration,
   normalizeMessage,
   normalizeSessionInfo,
   type SessionInfo,
@@ -29,8 +32,7 @@ import {
   shouldReplaceDelivery,
 } from "./snapshots.ts";
 
-const INTERCOM_DIR = join(getPiAgentDir(), "intercom");
-const PID_PATH = join(INTERCOM_DIR, "broker.pid");
+const PID_PATH = join(getBrokerRuntimeDir(), "broker.pid");
 const REPLACE_DELIVERY_DELAY_MS = 1500;
 
 interface ConnectedSession {
@@ -38,6 +40,8 @@ interface ConnectedSession {
   info: SessionInfo;
   topics: TopicSnapshot;
   readonly topicFrames: boolean;
+  readonly lastMessages: boolean;
+  readonly receiptReads: boolean;
 }
 
 interface PendingReplaceDelivery {
@@ -49,13 +53,13 @@ interface PendingReplaceDelivery {
 
 class IntercomBroker {
   private readonly sessions = new Map<string, ConnectedSession>();
+  private readonly lastMessages = new LastMessageRelay(this.sessions);
   private readonly pendingReplaceDeliveries = new Map<string, PendingReplaceDelivery>();
   private readonly server: net.Server;
   private shutdownTimer: NodeJS.Timeout | null = null;
   private readonly socketPath: string;
 
   constructor() {
-    mkdirSync(INTERCOM_DIR, { recursive: true });
     this.socketPath = prepareBrokerSocketPath();
     try {
       unlinkSync(this.socketPath);
@@ -82,30 +86,7 @@ class IntercomBroker {
   }
 
   private handleConnection(socket: net.Socket): void {
-    let sessionId: string | null = null;
-
-    const reader = createMessageReader(
-      (msg) => {
-        this.handleMessage(socket, msg, sessionId, (id) => {
-          sessionId = id;
-        });
-      },
-      (error) => {
-        socket.destroy(error);
-      },
-    );
-
-    socket.on("data", reader);
-
-    socket.on("close", () => {
-      if (sessionId !== null) {
-        this.removeSession(sessionId);
-      }
-    });
-
-    socket.on("error", (error) => {
-      console.error("Socket error:", error);
-    });
+    acceptBrokerConnection(socket, this.handleMessage.bind(this), this.removeSession.bind(this));
   }
 
   private scheduleShutdownCheck(): void {
@@ -158,6 +139,12 @@ class IntercomBroker {
       case "send":
         this.send(socket, msg, currentId);
         break;
+      case "last_request":
+        this.lastMessages.request(currentId, msg);
+        break;
+      case "last_response":
+        this.lastMessages.respond(currentId, msg);
+        break;
       case "presence":
         this.presence(msg, currentId);
         break;
@@ -167,16 +154,8 @@ class IntercomBroker {
   }
 
   private register(socket: net.Socket, msg: UnknownRecord, setId: (id: string) => void): void {
-    if (!isSessionRegistration(msg.session)) {
-      throw new Error("Invalid register message");
-    }
-    const requestedId =
-      typeof msg.requestedId === "string" && /^[a-zA-Z0-9_-]{8,80}$/.test(msg.requestedId)
-        ? msg.requestedId
-        : undefined;
-    const id =
-      requestedId !== undefined && !this.sessions.has(requestedId) ? requestedId : randomUUID();
-    const info: SessionInfo = { ...msg.session, id, lastSeen: msg.session.lastSeen ?? Date.now() };
+    const info = registeredSessionInfo(msg, this.sessions);
+    const id = info.id;
     snapshotFrames(randomUUID(), [info], true);
     const topicFrames = msg.topicFrames === true;
     this.sessions.set(id, {
@@ -184,6 +163,8 @@ class IntercomBroker {
       info: messageSender(info),
       topics: new TopicSnapshot(info),
       topicFrames,
+      lastMessages: msg.lastMessages === true,
+      receiptReads: msg.receiptReads === 1,
     });
     setId(id);
     if (this.shutdownTimer) {
@@ -193,14 +174,22 @@ class IntercomBroker {
     writeMessage(socket, {
       type: "registered",
       sessionId: id,
+      lastMessages: true,
+      receiptReads: 1,
+      ...(msg.guardedDelivery === 1 ? { guardedDelivery: 1 } : {}),
       ...(topicFrames ? { topicsSupported: true, topicFrames: true } : {}),
     });
   }
 
   private removeSession(sessionId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      return;
+    }
     this.sessions.delete(sessionId);
+    this.lastMessages.disconnected(sessionId);
     this.clearPendingReplaceDeliveries(sessionId);
-    this.broadcast({ type: "session_left", sessionId }, sessionId);
+    this.broadcast({ type: "session_left", sessionId }, session.info);
     this.scheduleShutdownCheck();
   }
 
@@ -215,7 +204,7 @@ class IntercomBroker {
     }
     for (const target of this.sessions.values()) {
       const subscription = target.topics.subscription(publication.topic);
-      if (target.info.id === fromId || !subscription) {
+      if (target.info.id === fromId || !subscription || !canSeeSession(from, target.info)) {
         continue;
       }
       const message = publicationMessage(publication, subscription.awaitRelease === true);
@@ -250,12 +239,14 @@ class IntercomBroker {
       }
       const infos = prepared.restore
         ? []
-        : [...this.sessions.values()].map((entry) => {
-            if (entry === session) {
-              return nextInfo;
-            }
-            return msg.stream === true ? entry.topics.snapshot(entry.info) : entry.info;
-          });
+        : [...this.sessions.values()]
+            .filter((entry) => canSeeSession(from, entry.info))
+            .map((entry) => {
+              if (entry === session) {
+                return nextInfo;
+              }
+              return msg.stream === true ? entry.topics.snapshot(entry.info) : entry.info;
+            });
       const frames = snapshotFrames(requestId, infos, msg.stream === true);
       const last = frames.pop();
       session.topics.commit(prepared);
@@ -297,9 +288,18 @@ class IntercomBroker {
       });
       return;
     }
-    const targets = this.findSessions(msg.to);
+    const targets = findSessions(this.sessions, msg.to, currentId);
     const target = targets[0];
     if (targets.length === 1) {
+      const guardError = guardedDeliveryError(this.sessions, msg.to, message);
+      if (guardError !== null) {
+        writeMessage(socket, {
+          type: "delivery_failed",
+          messageId: message.id,
+          reason: guardError,
+        });
+        return;
+      }
       const fromSession = this.sessions.get(currentId);
       if (!fromSession) {
         writeMessage(socket, {
@@ -347,11 +347,15 @@ class IntercomBroker {
       "lastIntercomActivity",
       "subscriptions",
       "topics",
+      "applicationGuard",
     ]) {
       if (msg[key] !== undefined) {
         update[key] = msg[key];
       }
     }
+    if (msg.applicationGuard === null) {
+      delete update.applicationGuard;
+    }
     const nextInfo = normalizeSessionInfo(update);
     if (!nextInfo) {
       throw new Error("Invalid presence update");
@@ -370,15 +374,7 @@ class IntercomBroker {
     message: Message,
   ): SendResult {
     const target = this.sessions.get(toId);
-    if (!target) {
-      return {
-        id: message.id,
-        accepted: false,
-        delivered: false,
-        reason: "Recipient disconnected before delivery",
-      };
-    }
-    if (shouldReplaceDelivery(message, target.info)) {
+    if (target && shouldReplaceDelivery(message, target.info)) {
       return this.queueReplaceDelivery(fromId, toId, from, message);
     }
     const reason = this.deliverMessage(toId, from, message);
@@ -469,6 +465,10 @@ class IntercomBroker {
   }
 
   private deliverMessage(toId: string, from: SessionInfo, message: Message): string | null {
+    const guardError = guardedDeliveryError(this.sessions, toId, message);
+    if (guardError !== null) {
+      return guardError;
+    }
     const target = this.sessions.get(toId);
     if (
       !target ||
@@ -495,21 +495,9 @@ class IntercomBroker {
     }
   }
 
-  private findSessions(nameOrId: string): ConnectedSession[] {
-    const byId = this.sessions.get(nameOrId);
-    if (byId) {
-      return [byId];
-    }
-
-    const lowerName = nameOrId.toLowerCase();
-    return Array.from(this.sessions.values()).filter(
-      (session) => session.info.name?.toLowerCase() === lowerName,
-    );
-  }
-
-  private broadcast(msg: BrokerMessage, exclude?: string): void {
+  private broadcast(msg: BrokerMessage, from: SessionInfo): void {
     for (const [id, session] of this.sessions) {
-      if (id !== exclude) {
+      if (id !== from.id && canSeeSession(session.info, from)) {
         writeMessage(session.socket, msg);
       }
     }
@@ -537,4 +525,5 @@ class IntercomBroker {
   }
 }
 
+await assertBrokerCanStart();
 new IntercomBroker().start();

package/src/pi-intercom/broker/client-last.ts

@@ -0,0 +1,78 @@
+import type net from "node:net";
+import { randomUUID } from "node:crypto";
+import { errorMessage, type UnknownRecord } from "../../shared/unknown.ts";
+import {
+  isNativeReadQuery,
+  isNativeReadResult,
+  isLastMessageResult,
+  isReceiptResult,
+  type NativeReadResult,
+} from "./last.ts";
+import type { LastMessageQuery, LastMessageResult, ReceiptQuery, ReceiptResult } from "../types.ts";
+import { writeMessage } from "./framing.ts";
+
+export class LastMessageRequests {
+  private readonly timeoutMs: number;
+  constructor(timeoutMs: number) {
+    this.timeoutMs = timeoutMs;
+  }
+  private readonly pending = new Map<
+    string,
+    {
+      readonly resolve: (result: NativeReadResult) => void;
+      readonly reject: (error: Readonly<Error>) => void;
+      readonly timer: NodeJS.Timeout;
+    }
+  >();
+
+  fail(error: Readonly<Error>): void {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+
+  receive(message: UnknownRecord): void {
+    if (typeof message.requestId !== "string" || !isNativeReadResult(message.result)) {
+      throw new Error("Invalid last-message response");
+    }
+    const pending = this.pending.get(message.requestId);
+    if (!pending) {
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pending.delete(message.requestId);
+    pending.resolve(message.result);
+  }
+
+  async last(socket: net.Socket, to: string, query: LastMessageQuery): Promise<LastMessageResult> {
+    const result = await this.request(socket, to, query);
+    return isLastMessageResult(result) ? result : { error: "Invalid last-message response" };
+  }
+  async receipt(socket: net.Socket, to: string, query: ReceiptQuery): Promise<ReceiptResult> {
+    const result = await this.request(socket, to, query);
+    return isReceiptResult(result) ? result : { error: "Invalid receipt response" };
+  }
+  private request(socket: net.Socket, to: string, query: unknown): Promise<NativeReadResult> {
+    if (!isNativeReadQuery(query)) {
+      return Promise.reject(new Error("Invalid last-message query"));
+    }
+    return new Promise((resolve, reject) => {
+      const requestId = randomUUID();
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        reject(new Error("Last-message read timeout"));
+      }, this.timeoutMs);
+      timer.unref();
+      this.pending.set(requestId, { resolve, reject, timer });
+      try {
+        writeMessage(socket, { type: "last_request", requestId, to, query });
+      } catch (error) {
+        clearTimeout(timer);
+        this.pending.delete(requestId);
+        reject(new Error(errorMessage(error)));
+      }
+    });
+  }
+}