@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/pi-intercom/broker/last.js

@@ -0,0 +1,173 @@
+import { randomUUID } from "node:crypto";
+import { isRecord } from "../../shared/unknown.js";
+import { normalizeSessionInfo, } from "../types.js";
+import { validateIntercomMessageSize, writeMessage } from "./framing.js";
+import { messageSender } from "./snapshots.js";
+import { findSessions } from "./targets.js";
+export const LAST_MESSAGE_PAGE_LIMIT = 16384;
+function nonNegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function optionalEntryId(value) {
+    return value === undefined || (typeof value === "string" && value.length > 0);
+}
+export function isLastMessageQuery(value) {
+    return (isRecord(value) &&
+        optionalEntryId(value.entryId) &&
+        (value.offset === undefined || nonNegativeInteger(value.offset)) &&
+        (value.limit === undefined ||
+            (nonNegativeInteger(value.limit) &&
+                value.limit > 0 &&
+                value.limit <= LAST_MESSAGE_PAGE_LIMIT)));
+}
+function pageIdentity(value) {
+    return (normalizeSessionInfo(value.session) !== null &&
+        (value.entryId === null || (typeof value.entryId === "string" && value.entryId.length > 0)) &&
+        typeof value.text === "string" &&
+        value.text.length <= LAST_MESSAGE_PAGE_LIMIT);
+}
+function pageOffsets(value) {
+    if (!nonNegativeInteger(value.offset) ||
+        !nonNegativeInteger(value.totalLength) ||
+        typeof value.text !== "string") {
+        return false;
+    }
+    const end = value.offset + value.text.length;
+    if (value.entryId === null) {
+        return end === 0 && value.totalLength === 0 && value.nextOffset === undefined;
+    }
+    if (value.nextOffset === undefined) {
+        return end === value.totalLength;
+    }
+    return value.nextOffset === end && end < value.totalLength && value.text.length > 0;
+}
+export function isLastMessageResult(value) {
+    return (isRecord(value) &&
+        (typeof value.error === "string" || (pageIdentity(value) && pageOffsets(value))));
+}
+function unavailable(targets, name, pending) {
+    if (targets.length === 0) {
+        return "Session not found";
+    }
+    if (targets.length > 1) {
+        return `Multiple sessions named "${name}" are connected. Use the session ID instead.`;
+    }
+    if (!targets[0].lastMessages) {
+        return "Recipient does not support last-message reads; reload its extension.";
+    }
+    if (pending >= 128) {
+        return "Too many pending last-message reads; retry after they settle.";
+    }
+    return undefined;
+}
+function matchesPage(result, pending, fromId) {
+    if ("error" in result) {
+        return true;
+    }
+    return (result.session.id === fromId &&
+        result.offset === (pending.query.offset ?? 0) &&
+        (pending.query.entryId === undefined || result.entryId === pending.query.entryId) &&
+        result.text.length <= (pending.query.limit ?? LAST_MESSAGE_PAGE_LIMIT));
+}
+/** Correlation belongs to the broker, not the requester or the recipient's model queue. */
+export class LastMessageRelay {
+    pending = new Map();
+    sessions;
+    constructor(sessions) {
+        this.sessions = sessions;
+    }
+    request(fromId, message) {
+        if (typeof message.requestId !== "string" ||
+            typeof message.to !== "string" ||
+            !isLastMessageQuery(message.query)) {
+            throw new Error("Invalid last message request");
+        }
+        const targets = findSessions(this.sessions, message.to, fromId);
+        const target = targets[0];
+        const from = this.sessions.get(fromId);
+        if (!from) {
+            return;
+        }
+        const error = unavailable(targets, message.to, this.pending.size);
+        if (error !== undefined) {
+            writeMessage(from.socket, {
+                type: "last_response",
+                requestId: message.requestId,
+                result: { error },
+            });
+            return;
+        }
+        const token = randomUUID();
+        const frame = {
+            type: "last_request",
+            requestId: token,
+            from: messageSender(from.info),
+            query: message.query,
+        };
+        const invalid = validateIntercomMessageSize(frame);
+        if (invalid) {
+            writeMessage(from.socket, {
+                type: "last_response",
+                requestId: message.requestId,
+                result: { error: invalid.message },
+            });
+            return;
+        }
+        const timer = setTimeout(() => this.finish(token, { error: "Last-message read timed out" }), 5000);
+        timer.unref();
+        this.pending.set(token, {
+            fromId,
+            toId: target.info.id,
+            requestId: message.requestId,
+            query: message.query,
+            timer,
+        });
+        try {
+            writeMessage(target.socket, frame);
+        }
+        catch {
+            this.finish(token, { error: "Recipient disconnected before last-message read" });
+        }
+    }
+    respond(fromId, message) {
+        if (typeof message.requestId !== "string") {
+            throw new Error("Invalid last message response");
+        }
+        const pending = this.pending.get(message.requestId);
+        if (!pending || pending.toId !== fromId) {
+            return;
+        }
+        const result = message.result;
+        this.finish(message.requestId, isLastMessageResult(result) && matchesPage(result, pending, fromId)
+            ? result
+            : { error: "Recipient returned an invalid last-message page" });
+    }
+    disconnected(sessionId) {
+        for (const [token, pending] of this.pending) {
+            if (pending.fromId === sessionId || pending.toId === sessionId) {
+                this.finish(token, { error: "Peer disconnected during last-message read" });
+            }
+        }
+    }
+    finish(token, result) {
+        const pending = this.pending.get(token);
+        if (!pending) {
+            return;
+        }
+        clearTimeout(pending.timer);
+        this.pending.delete(token);
+        const from = this.sessions.get(pending.fromId);
+        if (!from) {
+            return;
+        }
+        const frame = { type: "last_response", requestId: pending.requestId, result };
+        const invalid = validateIntercomMessageSize(frame);
+        writeMessage(from.socket, invalid
+            ? {
+                type: "last_response",
+                requestId: pending.requestId,
+                result: { error: invalid.message },
+            }
+            : frame);
+    }
+}

package/dist/pi-intercom/broker/paths.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import * as fs from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, isAbsolute, join } from "node:path";
 import { getPiAgentDir } from "../agent-dir.js";
 const MAX_UNIX_SOCKET_PATH_BYTES = 100;
 function agentDigest(agentDir, uid) {
@@ -10,8 +10,17 @@ function agentDigest(agentDir, uid) {
         .digest("hex")
         .slice(0, 16);
 }
-export function getLegacyBrokerSocketPath(agentDir = getPiAgentDir()) {
-    return join(tmpdir(), `pi-intercom-${agentDigest(agentDir)}.sock`);
+/** Old agent-directory namespaces are inspected for migration, never used for routing. */
+export function getPreviousBrokerSocketPaths() {
+    const agentDir = getPiAgentDir();
+    const suffix = `pi-intercom-${agentDigest(agentDir, process.getuid?.())}`;
+    const preferred = join(tmpdir(), suffix, "broker.sock");
+    return [
+        Buffer.byteLength(preferred) <= MAX_UNIX_SOCKET_PATH_BYTES
+            ? preferred
+            : join("/tmp", suffix, "broker.sock"),
+        join(tmpdir(), `pi-intercom-${agentDigest(agentDir)}.sock`),
+    ];
 }
 export function isOwnedBrokerSocket(socketPath) {
     try {
@@ -23,13 +32,23 @@ export function isOwnedBrokerSocket(socketPath) {
         return false;
     }
 }
-export function getBrokerSocketPath(agentDir = getPiAgentDir()) {
+/** A deployment can explicitly opt out of same-user discovery with a private runtime directory. */
+export function getBrokerRuntimeDir() {
+    const configured = process.env.PI_INTERCOM_RUNTIME_DIR;
     const uid = process.getuid?.();
-    const suffix = `pi-intercom-${agentDigest(agentDir, uid)}`;
-    const preferred = join(tmpdir(), suffix, "broker.sock");
-    return Buffer.byteLength(preferred) <= MAX_UNIX_SOCKET_PATH_BYTES
-        ? preferred
-        : join("/tmp", suffix, "broker.sock");
+    if (uid === undefined) {
+        throw new Error("Intercom requires Unix user IDs and Unix domain sockets.");
+    }
+    const directory = configured ?? join("/tmp", `pi-intercom-${uid}`);
+    if (!isAbsolute(directory) ||
+        directory.includes("\0") ||
+        Buffer.byteLength(join(directory, "broker.sock")) > MAX_UNIX_SOCKET_PATH_BYTES) {
+        throw new Error("PI_INTERCOM_RUNTIME_DIR must be an absolute short Unix socket directory.");
+    }
+    return directory;
+}
+export function getBrokerSocketPath() {
+    return join(getBrokerRuntimeDir(), "broker.sock");
 }
 export function prepareBrokerSocketPath() {
     const socketPath = getBrokerSocketPath();

package/dist/pi-intercom/broker/server-connection.js

@@ -0,0 +1,18 @@
+import { createMessageReader } from "./framing.js";
+/** A server connection owns its registration identity until the socket closes. */
+export function acceptBrokerConnection(socket, handleMessage, disconnected) {
+    let sessionId = null;
+    socket.on("data", createMessageReader((message) => handleMessage(socket, message, sessionId, (id) => {
+        sessionId = id;
+    }), (error) => {
+        socket.destroy(error);
+    }));
+    socket.on("close", () => {
+        if (sessionId !== null) {
+            disconnected(sessionId);
+        }
+    });
+    socket.on("error", (error) => {
+        console.error("Socket error:", error);
+    });
+}

package/dist/pi-intercom/broker/spawn.js

@@ -1,17 +1,15 @@
 import { spawn } from "child_process";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-import { mkdir } from "fs/promises";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
 import net from "net";
 import { getPiAgentDir } from "../agent-dir.js";
-import { getBrokerSocketPath, getLegacyBrokerSocketPath, isOwnedBrokerSocket } from "./paths.js";
+import { getBrokerRuntimeDir, getBrokerSocketPath, getPreviousBrokerSocketPaths, isOwnedBrokerSocket, prepareBrokerSocketPath, } from "./paths.js";
 import { isBrokerPidReused } from "./pid.js";
 import { errorMessage, hasErrorCode } from "../../shared/unknown.js";
-const INTERCOM_DIR = join(getPiAgentDir(), "intercom");
 const EXTENSION_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
-const BROKER_PID = join(INTERCOM_DIR, "broker.pid");
-const BROKER_SPAWN_LOCK = join(INTERCOM_DIR, "broker.spawn.lock");
+const BROKER_PID = join(getBrokerRuntimeDir(), "broker.pid");
+const BROKER_SPAWN_LOCK = join(getBrokerRuntimeDir(), "broker.spawn.lock");
 function sleep(ms) {
     return new Promise((resolve) => {
         setTimeout(resolve, ms);
@@ -47,7 +45,8 @@ function toError(error) {
     return error instanceof Error ? error : new Error(errorMessage(error));
 }
 export async function spawnBrokerIfNeeded(brokerCommand, brokerArgs) {
-    await mkdir(INTERCOM_DIR, { recursive: true });
+    prepareBrokerSocketPath();
+    await warnPreviousBroker();
     if (await isBrokerRunning()) {
         return;
     }
@@ -102,13 +101,19 @@ export async function spawnBrokerIfNeeded(brokerCommand, brokerArgs) {
 export async function isBrokerRunning() {
     return checkSocketConnectable();
 }
-function readLivePid() {
-    if (!existsSync(BROKER_PID)) {
+export async function assertBrokerCanStart() {
+    if (await isBrokerRunning()) {
+        throw new Error("Intercom broker is already running; refusing to replace its socket.");
+    }
+    await stopUnhealthyBrokerBeforeSpawn();
+}
+function readLivePid(pidPath) {
+    if (!existsSync(pidPath)) {
         return null;
     }
     let raw;
     try {
-        raw = readFileSync(BROKER_PID, "utf-8");
+        raw = readFileSync(pidPath, "utf-8");
     }
     catch {
         return null;
@@ -125,23 +130,34 @@ function readLivePid() {
     }
     return isBrokerPidReused(pid, raw) ? null : pid;
 }
+async function warnPreviousBroker() {
+    const previousSockets = getPreviousBrokerSocketPaths();
+    for (const socketPath of previousSockets) {
+        // Migration probes are sequential and never register or send to old peers.
+        // oxlint-disable-next-line no-await-in-loop
+        if (isOwnedBrokerSocket(socketPath) && (await checkOneSocket(socketPath))) {
+            console.warn("An older agent-directory Intercom broker is still running. Its peers are not part of shared same-user discovery until they reload with the updated extension. Existing sessions and accepted work are untouched; no legacy fallback is used.");
+            return;
+        }
+    }
+    const previousPid = readLivePid(join(getPiAgentDir(), "intercom", "broker.pid"));
+    if (previousPid !== null) {
+        console.warn(`Older Intercom broker PID ${previousPid} may still own accepted work. Its peers need to reload with the updated extension to join shared same-user discovery. Nothing was stopped or replaced; no legacy fallback is used.`);
+    }
+}
 export async function stopUnhealthyBrokerBeforeSpawn() {
     if (await checkSocketConnectable()) {
         return;
     }
-    const pid = readLivePid();
+    const pid = readLivePid(BROKER_PID);
     if (pid === null) {
         return;
     }
     throw new Error(`Intercom broker PID ${pid} may still own accepted work but its socket is unhealthy; refusing to spawn a second broker. Let the broker exit normally, then retry.`);
 }
 async function checkSocketConnectable() {
-    const preferred = getBrokerSocketPath();
-    if (isOwnedBrokerSocket(preferred) && (await checkOneSocket(preferred))) {
-        return true;
-    }
-    const legacy = getLegacyBrokerSocketPath();
-    return legacy !== preferred && isOwnedBrokerSocket(legacy) && (await checkOneSocket(legacy));
+    const socketPath = getBrokerSocketPath();
+    return isOwnedBrokerSocket(socketPath) && (await checkOneSocket(socketPath));
 }
 function checkOneSocket(brokerSocket) {
     return new Promise((resolve) => {

package/dist/pi-intercom/broker/targets.js

@@ -0,0 +1,24 @@
+import { nativePeerId } from "../session-targets.js";
+export function canSeeSession(from, target) {
+    return ((from.rootSessionId ?? from.id) === (target.rootSessionId ?? target.id) ||
+        (from.parentSessionId === undefined && target.parentSessionId === undefined));
+}
+export function assertMainParent(session, sessions) {
+    if (session.parentSessionId !== undefined &&
+        sessions.get(nativePeerId(session.parentSessionId))?.info.parentSessionId !== undefined) {
+        throw new Error("Nested child sessions are not supported.");
+    }
+}
+/** Preserve exact-ID precedence and case-insensitive duplicate-name ambiguity. */
+export function findSessions(sessions, nameOrId, fromId) {
+    const from = sessions.get(fromId);
+    if (!from) {
+        return [];
+    }
+    const byId = sessions.get(nameOrId);
+    if (byId && canSeeSession(from.info, byId.info)) {
+        return [byId];
+    }
+    const lowerName = nameOrId.toLowerCase();
+    return [...sessions.values()].filter((session) => canSeeSession(from.info, session.info) && session.info.name?.toLowerCase() === lowerName);
+}

package/dist/pi-intercom/config.js

@@ -1,10 +1,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { Key } from "@earendil-works/pi-tui";
 import { getPiAgentDir } from "./agent-dir.js";
 import { isRecord, isUnknownArray } from "./validation.js";
 const defaults = {
-    shortcut: Key.altShift("m"),
     brokerCommand: process.execPath,
     brokerArgs: [],
     confirmSend: false,
@@ -13,13 +11,6 @@ const defaults = {
     sendTimeoutMs: 8000,
     listTimeoutMs: 5000,
 };
-const namedKeys = new Set(Object.values(Key).filter((key) => typeof key === "string"));
-function isShortcut(value) {
-    const prefix = value.match(/^(?:(?:ctrl|shift|alt|super)\+)+/)?.[0] ?? "";
-    const modifiers = prefix.split("+").filter(Boolean);
-    const key = value.slice(prefix.length);
-    return (new Set(modifiers).size === modifiers.length && (namedKeys.has(key) || /^[a-z0-9]$/.test(key)));
-}
 function configuredString(parsed, key) {
     if (!Object.hasOwn(parsed, key)) {
         return defaults[key];
@@ -39,19 +30,6 @@ function configuredString(parsed, key) {
 function brokerCommand(parsed) {
     return configuredString(parsed, "brokerCommand") ?? defaults.brokerCommand;
 }
-function configuredShortcut(parsed) {
-    if (!Object.hasOwn(parsed, "shortcut")) {
-        return defaults.shortcut;
-    }
-    if (typeof parsed.shortcut !== "string") {
-        throw new Error('"shortcut" must be a native key identifier');
-    }
-    const shortcut = parsed.shortcut.trim();
-    if (!isShortcut(shortcut)) {
-        throw new Error('"shortcut" must be a native key identifier, for example alt+shift+m');
-    }
-    return shortcut;
-}
 function configuredArgs(parsed) {
     if (!Object.hasOwn(parsed, "brokerArgs")) {
         return defaults.brokerArgs;
@@ -98,7 +76,6 @@ export function loadConfig() {
             throw new Error("Config must be a JSON object");
         }
         return {
-            shortcut: configuredShortcut(parsed),
             brokerCommand: brokerCommand(parsed),
             brokerArgs: configuredArgs(parsed),
             confirmSend: configuredBoolean(parsed, "confirmSend"),

package/dist/pi-intercom/connection.js

@@ -1,6 +1,7 @@
 import { IntercomClient } from "./broker/client.js";
 import { spawnBrokerIfNeeded } from "./broker/spawn.js";
-import { asError, errorMessage } from "./validation.js";
+import { readLastMessage } from "./last-message.js";
+import { asError } from "./validation.js";
 import { formatTargetOptions, resolveSessionTarget, nativePeerId } from "./session-targets.js";
 /** Owns socket registration, coalesced connects and the reconnect/startup timers. */
 export class IntercomConnection {
@@ -10,32 +11,19 @@ export class IntercomConnection {
     connecting = null;
     connectingGeneration = null;
     attempt = 0;
-    syncError;
     lifecycle;
     config;
-    topics;
     hooks;
-    constructor(lifecycle, config, topics, hooks) {
+    constructor(lifecycle, config, hooks) {
         this.lifecycle = lifecycle;
         this.config = config;
-        this.topics = topics;
         this.hooks = hooks;
     }
     get active() {
         return this.client;
     }
-    get topicSyncError() {
-        return this.syncError;
-    }
-    get isConnecting() {
-        return this.startupTimer !== null || this.connecting !== null;
-    }
-    clearTopicSyncError() {
-        this.syncError = undefined;
-    }
     start(ctx, generation) {
         this.attempt = 0;
-        this.syncError = undefined;
         this.clearTimers();
         this.scheduleStartup(ctx, generation);
     }
@@ -62,7 +50,7 @@ export class IntercomConnection {
             if (!this.lifecycle.live(ctx, generation)) {
                 return;
             }
-            this.ensure("startup").catch(() => {
+            this.ensure().catch(() => {
                 if (!this.lifecycle.live(ctx, generation)) {
                     return;
                 }
@@ -85,7 +73,7 @@ export class IntercomConnection {
                 return;
             }
             this.attempt += 1;
-            this.ensure("background").catch(() => {
+            this.ensure().catch(() => {
                 /* ensure owns the next retry after settlement. */
             });
         }, delay);
@@ -114,6 +102,26 @@ export class IntercomConnection {
             listTimeoutMs: this.config.listTimeoutMs,
         });
         this.client = next;
+        next.on("last_request", (request) => {
+            const ctx = this.lifecycle.live();
+            const id = next.sessionId;
+            if (this.client !== next || !ctx || id === null) {
+                next.respondLast(request.requestId, { error: "Intercom runtime no longer active" });
+                return;
+            }
+            try {
+                next.respondLast(request.requestId, readLastMessage(ctx.sessionManager, {
+                    id,
+                    ...this.lifecycle.identity(ctx.sessionManager.getSessionId()),
+                    cwd: ctx.cwd,
+                    model: ctx.model?.id ?? "unknown",
+                    status: this.lifecycle.status(),
+                }, request.query));
+            }
+            catch (error) {
+                next.respondLast(request.requestId, { error: asError(error).message });
+            }
+        });
         next.on("message", (from, message) => {
             const ctx = this.lifecycle.live();
             if (this.client !== next || !ctx) {
@@ -127,7 +135,6 @@ export class IntercomConnection {
             if (this.client !== next) {
                 return;
             }
-            this.topics.disconnected(id);
             this.hooks.peerLeft(id);
         });
         next.on("disconnected", (error) => {
@@ -136,7 +143,6 @@ export class IntercomConnection {
             }
             this.hooks.disconnected(error);
             this.client = null;
-            this.topics.disconnected();
             this.clearReconnect();
             this.scheduleReconnect();
         });
@@ -145,55 +151,10 @@ export class IntercomConnection {
         });
         return next;
     }
-    async restoreTopics(active) {
-        const changes = [
-            ...[...this.topics.presence().topics].map((topic) => ({
-                action: "restore",
-                topic,
-            })),
-            ...[...this.topics.presence().subscriptions].map((subscription) => ({
-                action: "restore",
-                subscription,
-            })),
-        ];
-        let failure;
-        for (const change of changes) {
-            try {
-                // Restore order preserves publication/subscription admission and bounded transport pressure.
-                // oxlint-disable-next-line no-await-in-loop
-                await active.updateTopics(change);
-            }
-            catch (error) {
-                if (!active.isConnected()) {
-                    throw error;
-                }
-                failure ??= errorMessage(error);
-            }
-        }
-        return failure;
-    }
-    async synchronizeTopics(next, ctx, generation) {
-        if (!next.supportsTopics) {
-            this.topics.disconnected();
-            return;
-        }
-        const failure = await this.restoreTopics(next);
-        const sessions = await next.listSessions();
-        if (!this.lifecycle.live(ctx, generation)) {
-            return;
-        }
-        this.syncError = failure;
-        this.topics.refresh(sessions);
-        if (failure !== undefined && failure !== "" && next.sessionId !== null) {
-            this.topics.disconnected(next.sessionId);
-        }
-    }
-    async connect(reason, ctx, generation, sessionId) {
+    async connect(ctx, generation, sessionId) {
         const next = this.createClient();
         try {
-            if (reason !== "peer-awareness") {
-                await spawnBrokerIfNeeded(this.config.brokerCommand, this.config.brokerArgs);
-            }
+            await spawnBrokerIfNeeded(this.config.brokerCommand, this.config.brokerArgs);
             await next.connect(await this.lifecycle.registration(this.hooks.pendingAsks()), nativePeerId(sessionId));
             if (!this.lifecycle.live(ctx, generation)) {
                 await next.disconnect();
@@ -202,21 +163,20 @@ export class IntercomConnection {
             this.client = next;
             this.syncIdentity(ctx.sessionManager.getSessionId());
             this.attempt = 0;
-            await this.synchronizeTopics(next, ctx, generation);
             return next;
         }
         catch (error) {
             if (this.client === next) {
                 this.client = null;
             }
-            // A failed topic snapshot can leave a registered socket alive; the attempt still owns it.
+            // A failed registration still owns its socket.
             await next.disconnect().catch((cleanupError) => {
                 console.error("Intercom failed connection cleanup:", cleanupError);
             });
             throw asError(error);
         }
     }
-    async ensure(reason) {
+    async ensure() {
         const generation = this.lifecycle.generation;
         const restoring = this.hooks.restoring();
         if (restoring) {
@@ -238,7 +198,7 @@ export class IntercomConnection {
         }
         this.clearReconnect();
         // Publish ownership before registration, which can synchronously invoke subscribers.
-        const attempt = Promise.resolve().then(() => this.connect(reason, ctx, generation, sessionId));
+        const attempt = Promise.resolve().then(() => this.connect(ctx, generation, sessionId));
         this.connecting = attempt;
         this.connectingGeneration = generation;
         return await this.finishAttempt(attempt, ctx, generation);