@fitchmultz/pi-subagents 0.49.1 → 0.50.0

package/src/pi-intercom/bridge-session.ts

@@ -7,13 +7,9 @@ import type { Identity } from "./bridge-config.ts";
 import { Fault, cancelled, log, wait } from "./bridge-protocol.ts";
 import { Mailbox } from "./bridge-mailbox.ts";
 import type { UnknownRecord } from "../shared/unknown.ts";
-import type { MessagingOperation as Operation } from "./bridge-routes.ts";
+import type { Operation } from "./bridge-routes.ts";
 import type { RequestContext } from "./bridge-http.ts";
 import { resolveBridgeTarget, bridgeSessionList } from "./bridge-target.ts";
-import { ControlReplies } from "./bridge-control.ts";
-import type { NativeControlOperation } from "./native-control-protocol.ts";
-
-import { WaitingAsk } from "./bridge-ask.ts";
 const MAX_REQUESTS = 8;
 const IDLE_TIMEOUT = 5 * 60 * 1000;
 const SEND_TIMEOUT = 8000;
@@ -44,9 +40,6 @@ export class Session {
   private readonly requests = new Set<AbortController>();
   private readonly inbox: Mailbox;
   private inboxChanged = new AbortController();
-  private readonly replying = new Set<string>();
-  private pending?: WaitingAsk;
-  private readonly controls = new ControlReplies();
   private closed = false;
   private connecting?: Promise<void>;
   private disconnecting?: Promise<void>;
@@ -72,7 +65,6 @@ export class Session {
       }
     });
     this.client.on("message", (from: SessionInfo, message: Message) => this.receive(from, message));
-    this.client.on("session_left", (id: string) => this.peerLeft(id));
     this.touch();
   }
 
@@ -202,8 +194,6 @@ export class Session {
     this.closed = true;
     this.closeReason = fault;
     clearTimeout(this.lease);
-    this.pending?.reject(fault);
-    this.controls.close(fault);
     for (const controller of this.requests) {
       controller.abort(fault);
     }
@@ -214,15 +204,6 @@ export class Session {
     await this.retirement;
   }
 
-  private peerLeft(id: string): void {
-    this.controls.peerLeft(id);
-    if (this.pending?.peer === id && !this.pending.settled) {
-      this.pending.reject(
-        new Fault(409, "peer_offline", "Ask recipient disconnected.", { id: this.pending.id }),
-      );
-    }
-    this.presence();
-  }
   private receive(from: SessionInfo, message: Message): void {
     if (this.closed) {
       return;
@@ -237,12 +218,6 @@ export class Session {
       );
       return;
     }
-    if (this.controls.receive(from.id, message)) {
-      return;
-    }
-    if (!this.inbox.persistent && this.resolveReply(from, message)) {
-      return;
-    }
     this.storeReceive(from, message);
   }
   private storeReceive(from: SessionInfo, message: Message): void {
@@ -280,19 +255,10 @@ export class Session {
       result: result === "lost" && this.inbox.persistent ? "storage_failed" : result,
     });
     if (result !== "lost") {
-      this.resolveReply(from, message);
       this.owner.mailboxChanged?.();
     }
     this.presence();
   }
-  private resolveReply(from: SessionInfo, message: Message): boolean {
-    const pending = this.pending;
-    if (pending?.matches(from.id, message.replyTo) !== true) {
-      return false;
-    }
-    pending.resolve({ from, message });
-    return true;
-  }
   private presence(): void {
     if (this.closed) {
       return;
@@ -318,19 +284,6 @@ export class Session {
     await this.connect(signal);
     return this.peers(signal);
   }
-  async nativeControl(
-    operation: NativeControlOperation,
-    certificate: string,
-    context: RequestContext,
-  ): Promise<UnknownRecord> {
-    await this.connect(context.signal);
-    const peer = await this.target(operation.to, context.signal);
-    return this.controls.request(
-      this.client,
-      { ...operation, peer: peer.id, certificate },
-      { ...context, guard: () => this.guard(context.signal) },
-    );
-  }
   private async target(to: string, signal: AbortSignal): Promise<SessionInfo> {
     return resolveBridgeTarget(await this.peers(signal), to, this.client.sessionId);
   }
@@ -380,34 +333,6 @@ export class Session {
     }
     return result;
   }
-  private async ask(
-    operation: Extract<Operation, { readonly route: "POST /v1/ask" }>,
-    context: RequestContext,
-  ): Promise<UnknownRecord> {
-    if (this.pending) {
-      throw new Fault(409, "ask_in_progress", "Only one concurrent ask is allowed per identity.");
-    }
-    const waiting = new WaitingAsk();
-    this.pending = waiting;
-    const { signal } = context;
-    try {
-      await this.connect(signal);
-      const peer = await this.target(operation.to, signal);
-      this.guard(signal);
-      waiting.peer = peer.id;
-      waiting.deadline(operation.timeoutMs, (error) => this.close(error));
-      waiting.receipt = await this.send(peer.id, operation.message, context, {
-        messageId: waiting.id,
-        expectsReply: true,
-      });
-      const answer = await wait(waiting.reply, signal);
-      this.guard(signal);
-      return { ...waiting.receipt, replied: true, reply: answer };
-    } finally {
-      waiting.clear();
-      this.pending = undefined;
-    }
-  }
   private async readInbox(
     operation: Extract<Operation, { readonly route: "GET /v1/inbox" }>,
     context: RequestContext,
@@ -439,44 +364,8 @@ export class Session {
       this.guard(context.signal);
     }
   }
-  private async answer(
-    replyTo: string,
-    message: string,
-    context: RequestContext,
-  ): Promise<UnknownRecord> {
-    const entry = this.inbox.get(replyTo);
-    if (entry?.message.expectsReply !== true) {
-      throw new Fault(404, "unknown_ask", "replyTo must identify an unanswered inbound ask.");
-    }
-    if (this.replying.has(replyTo)) {
-      throw new Fault(409, "reply_in_progress", "This ask already has a reply in flight.");
-    }
-    this.replying.add(replyTo);
-    const peer = entry.from.id;
-    context.onPeer(peer);
-    try {
-      const peers = await this.peers(context.signal);
-      if (!peers.some((candidate) => candidate.id === peer)) {
-        throw new Fault(409, "peer_offline", "Original ask sender is disconnected.");
-      }
-      this.guard(context.signal);
-      if (!this.inbox.get(replyTo)) {
-        throw new Fault(409, "ask_retired", "Inbound ask is no longer replyable.");
-      }
-      const data = { ...(await this.send(peer, message, context, { replyTo })) };
-      this.inbox.remove(replyTo);
-      this.owner.mailboxChanged?.();
-      this.presence();
-      return data;
-    } finally {
-      this.replying.delete(replyTo);
-    }
-  }
   async execute(operation: Operation, context: RequestContext): Promise<UnknownRecord> {
     this.guard(context.signal);
-    if (operation.route === "POST /v1/ask") {
-      return this.ask(operation, context);
-    }
     if (operation.route === "GET /v1/inbox" || operation.route === "POST /v1/ack") {
       // Durable reads/acks remain available while the local broker is down.
       if (!this.inbox.persistent) {
@@ -503,12 +392,12 @@ export class Session {
         const peer = await this.target(operation.to, context.signal);
         const receipt = await this.send(peer.id, operation.message, context, {
           messageId: operation.messageId,
+          replyTo: operation.replyTo,
+          expectsReply: operation.expectsReply,
           delivery: operation.passive === true ? "passive" : "steer",
         });
         return { ...receipt };
       }
-      case "POST /v1/reply":
-        return this.answer(operation.replyTo, operation.message, context);
     }
   }
 }

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,11 +1,14 @@
 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 { assertMainParent, canSeeSession, findSessions } from "./targets.ts";
+import { acceptBrokerConnection } from "./server-connection.ts";
 import {
   compactTopicMessage,
   isSessionRegistration,
@@ -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,7 @@ interface ConnectedSession {
   info: SessionInfo;
   topics: TopicSnapshot;
   readonly topicFrames: boolean;
+  readonly lastMessages: boolean;
 }
 
 interface PendingReplaceDelivery {
@@ -49,13 +52,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 +85,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 +138,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;
@@ -170,6 +156,7 @@ class IntercomBroker {
     if (!isSessionRegistration(msg.session)) {
       throw new Error("Invalid register message");
     }
+    assertMainParent(msg.session, this.sessions);
     const requestedId =
       typeof msg.requestedId === "string" && /^[a-zA-Z0-9_-]{8,80}$/.test(msg.requestedId)
         ? msg.requestedId
@@ -184,6 +171,7 @@ class IntercomBroker {
       info: messageSender(info),
       topics: new TopicSnapshot(info),
       topicFrames,
+      lastMessages: msg.lastMessages === true,
     });
     setId(id);
     if (this.shutdownTimer) {
@@ -193,14 +181,20 @@ class IntercomBroker {
     writeMessage(socket, {
       type: "registered",
       sessionId: id,
+      lastMessages: true,
       ...(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 +209,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 +244,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,7 +293,7 @@ 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 fromSession = this.sessions.get(currentId);
@@ -495,21 +491,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 +521,5 @@ class IntercomBroker {
   }
 }
 
+await assertBrokerCanStart();
 new IntercomBroker().start();

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

@@ -0,0 +1,65 @@
+import type net from "node:net";
+import { randomUUID } from "node:crypto";
+import { errorMessage, type UnknownRecord } from "../../shared/unknown.ts";
+import type { LastMessageResult } from "../types.ts";
+import { isLastMessageQuery, isLastMessageResult } from "./last.ts";
+import { writeMessage } from "./framing.ts";
+
+export class LastMessageRequests {
+  private readonly pending = new Map<
+    string,
+    {
+      readonly resolve: (result: LastMessageResult) => 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" || !isLastMessageResult(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);
+  }
+
+  request(
+    socket: net.Socket,
+    to: string,
+    query: unknown,
+    timeoutMs: number,
+  ): Promise<LastMessageResult> {
+    if (!isLastMessageQuery(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"));
+      }, 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)));
+      }
+    });
+  }
+}