pi-sessions 0.5.1 → 0.7.0

package/extensions/session-messaging/pi/message-view.ts

@@ -0,0 +1,131 @@
+import { Box, type Component, getKeybindings, type Keybinding, Text } from "@earendil-works/pi-tui";
+import type { ReceivedMessageEntry } from "./message-contracts.ts";
+
+const COLLAPSED_MESSAGE_LINES = 10;
+
+interface MessageViewTheme {
+  bold(text: string): string;
+  fg(token: string, text: string): string;
+  bg(token: string, text: string): string;
+}
+
+interface MessageViewOptions {
+  expanded: boolean;
+  status: "sending" | "received";
+  targetSessionId?: string | undefined;
+  sourceSessionId?: string | undefined;
+  sourceSessionName?: string | undefined;
+  message: string;
+  requestResponse?: boolean | undefined;
+  relation?: string | undefined;
+}
+
+export function renderSessionMessageView(
+  options: MessageViewOptions,
+  theme: MessageViewTheme,
+): string {
+  const header = formatHeader(options, theme);
+  const body = formatMessageBody(options.message, options.expanded, theme);
+  return body ? `${header}\n\n${body}` : header;
+}
+
+export function createReceivedSessionMessageComponent(
+  received: ReceivedMessageEntry,
+  expanded: boolean,
+  theme: MessageViewTheme,
+): Component {
+  const box = new Box(1, 1, (text: string) => theme.bg("toolSuccessBg", text));
+  box.addChild(
+    new Text(
+      renderSessionMessageView(
+        {
+          expanded,
+          status: "received",
+          sourceSessionId: received.source.sessionId,
+          sourceSessionName: received.source.sessionName,
+          message: received.body,
+          requestResponse: received.requestResponse,
+          relation: received.relation,
+        },
+        theme,
+      ),
+      0,
+      0,
+    ),
+  );
+  return box;
+}
+
+export function formatSendMessageCall(
+  args: { session?: string; message?: string; requestResponse?: boolean } | undefined,
+  expanded: boolean,
+  status: "sending",
+  theme: MessageViewTheme,
+  relation?: string | undefined,
+): string {
+  return renderSessionMessageView(
+    {
+      expanded,
+      status,
+      targetSessionId: args?.session,
+      message: args?.message ?? "",
+      requestResponse: args?.requestResponse,
+      relation,
+    },
+    theme,
+  );
+}
+
+function formatHeader(options: MessageViewOptions, theme: MessageViewTheme): string {
+  const toolName = options.status === "received" ? "incoming_message" : "session_send_message";
+  const name = theme.fg("toolTitle", theme.bold(toolName));
+  const metadata = [
+    options.relation,
+    options.requestResponse ? "response requested" : undefined,
+  ].filter((item): item is string => Boolean(item));
+  const metadataHint = metadata.length > 0 ? theme.fg("muted", ` (${metadata.join(", ")})`) : "";
+  switch (options.status) {
+    case "received":
+      return `${name} ${theme.fg("muted", `from ${formatSourceLabel(options)}`)}${metadataHint}`;
+    case "sending":
+      return `${name} ${theme.fg("muted", `to ${options.targetSessionId ?? "[target pending]"}`)}${metadataHint}`;
+  }
+}
+
+function formatSourceLabel(options: MessageViewOptions): string {
+  if (!options.sourceSessionId) {
+    return "[source unknown]";
+  }
+
+  const title = options.sourceSessionName?.trim();
+  return title ? `${title} (${options.sourceSessionId})` : options.sourceSessionId;
+}
+
+function formatKeyHint(
+  keybinding: Keybinding,
+  description: string,
+  theme: MessageViewTheme,
+): string {
+  const keyText = getKeybindings().getKeys(keybinding).join("/");
+  return `${theme.fg("dim", keyText)}${theme.fg("muted", ` ${description}`)}`;
+}
+
+function formatMessageBody(message: string, expanded: boolean, theme: MessageViewTheme): string {
+  if (!message) {
+    return "";
+  }
+
+  const lines = message.replaceAll("\t", "  ").split("\n");
+  const maxLines = expanded ? lines.length : COLLAPSED_MESSAGE_LINES;
+  const visibleLines = lines.slice(0, maxLines);
+  const remaining = lines.length - visibleLines.length;
+  const body = visibleLines.map((line) => theme.fg("toolOutput", line)).join("\n");
+  if (remaining <= 0) {
+    return body;
+  }
+
+  return `${body}${theme.fg(
+    "muted",
+    `\n... (${remaining} more lines, ${lines.length} total,`,
+  )} ${formatKeyHint("app.tools.expand", "to expand", theme)}${theme.fg("muted", ")")}`;
+}

package/extensions/session-messaging/pi/renderer.ts

@@ -0,0 +1,16 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { safeParseTypeBoxValue } from "../../shared/typebox.ts";
+import { SESSION_MESSAGE_CUSTOM_TYPE } from "./incoming-runtime.ts";
+import { RECEIVED_MESSAGE_ENTRY_SCHEMA } from "./message-contracts.ts";
+import { createReceivedSessionMessageComponent } from "./message-view.ts";
+
+export function registerSessionMessagingRenderer(pi: ExtensionAPI): void {
+  pi.registerMessageRenderer(SESSION_MESSAGE_CUSTOM_TYPE, (message, options, theme) => {
+    const details = safeParseTypeBoxValue(RECEIVED_MESSAGE_ENTRY_SCHEMA, message.details);
+    if (!details) {
+      return undefined;
+    }
+
+    return createReceivedSessionMessageComponent(details, options.expanded, theme);
+  });
+}

package/extensions/session-messaging/pi/service.ts

@@ -0,0 +1,370 @@
+import { randomUUID } from "node:crypto";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+  type ActiveSessionBrokerConnection,
+  setActiveSessionBrokerConnection,
+} from "../../shared/session-broker/active.ts";
+import {
+  INCOMING_SESSION_MESSAGE_EVENT,
+  type SessionMessageSendResult,
+  SessionMessagingClient,
+} from "../../shared/session-broker/client.ts";
+import type { SessionMessagePayload } from "../../shared/session-broker/protocol.ts";
+import type {
+  SessionLineageRelation,
+  SessionLineageRow,
+} from "../../shared/session-index/index.ts";
+import {
+  getLineageRelationMap,
+  getSessionById,
+  withSessionIndex,
+} from "../../shared/session-index/index.ts";
+import { spawnSessionMessagingBrokerIfNeeded } from "../broker/spawn.ts";
+import type { IncomingSessionMessageRuntime } from "./incoming-runtime.ts";
+import type { ReceivedMessageEndpoint, ReceivedMessageEntry } from "./message-contracts.ts";
+
+export const MESSAGE_SENT_CUSTOM_TYPE = "pi-sessions.message_sent";
+
+const RECONNECT_DELAYS_MS = [250, 500, 1_000, 2_000, 5_000, 10_000, 30_000] as const;
+
+export interface SendMessageRequest {
+  target: string;
+  body: string;
+  requestResponse?: boolean | undefined;
+  sourceToolCallId?: string | undefined;
+}
+
+interface IncomingMessageIndexContext {
+  source: ReceivedMessageEndpoint;
+  target: ReceivedMessageEndpoint;
+  relation?: SessionLineageRelation | undefined;
+}
+
+export class SessionMessagingService {
+  private readonly indexPath: string;
+  private readonly incomingRuntime: IncomingSessionMessageRuntime;
+  private readonly appendEntry: (customType: string, data: unknown) => void;
+  private relationBySessionId = new Map<string, SessionLineageRelation | undefined>();
+  private readonly connection = new BrokerConnection((requestId, message) =>
+    this.handleIncoming(requestId, message),
+  );
+
+  constructor(
+    indexPath: string,
+    incomingRuntime: IncomingSessionMessageRuntime,
+    appendEntry: (customType: string, data: unknown) => void,
+  ) {
+    this.indexPath = indexPath;
+    this.incomingRuntime = incomingRuntime;
+    this.appendEntry = appendEntry;
+  }
+
+  async start(ctx: ExtensionContext): Promise<void> {
+    const sessionId = ctx.sessionManager.getSessionId();
+    this.refreshCachedRelations(sessionId);
+    setActiveSessionBrokerConnection(this.connection);
+    await this.connection.start(sessionId);
+  }
+
+  stop(): void {
+    setActiveSessionBrokerConnection(undefined);
+    this.relationBySessionId.clear();
+    this.connection.stop();
+  }
+
+  async sendMessage(request: SendMessageRequest): Promise<SessionMessageSendResult> {
+    const relation = this.getCachedRelationTo(request.target, true);
+    const sentAt = new Date().toISOString();
+    const messageId = randomUUID();
+    const result = await this.connection.sendMessage({
+      messageId,
+      target: request.target,
+      body: request.body,
+      sentAt,
+      requestResponse: request.requestResponse,
+      sourceToolCallId: request.sourceToolCallId,
+    });
+
+    if (result.delivered) {
+      this.appendEntry(MESSAGE_SENT_CUSTOM_TYPE, {
+        messageId: result.messageId,
+        target: request.target,
+        body: request.body,
+        requestResponse: request.requestResponse,
+        sourceToolCallId: request.sourceToolCallId,
+        sentAt,
+        ...(relation === undefined ? {} : { relation }),
+      });
+    }
+
+    return result;
+  }
+
+  private handleIncoming(requestId: string, message: SessionMessagePayload): void {
+    const received = this.buildReceivedMessageEntry(message);
+    const result = this.incomingRuntime.deliver(received);
+    this.connection.acknowledgeIncoming(requestId, message.messageId, result);
+  }
+
+  getCachedRelationTo(
+    sessionId: string | undefined,
+    refresh = false,
+  ): SessionLineageRelation | undefined {
+    if (!sessionId) {
+      return undefined;
+    }
+
+    if (this.relationBySessionId.has(sessionId)) {
+      return this.relationBySessionId.get(sessionId);
+    }
+
+    if (!refresh) {
+      return undefined;
+    }
+
+    const identity = this.connection.currentSessionId;
+    if (!identity) {
+      throw new Error("Session messaging is not active.");
+    }
+
+    this.refreshCachedRelations(identity);
+    if (!this.relationBySessionId.has(sessionId)) {
+      this.relationBySessionId.set(sessionId, undefined);
+    }
+
+    return this.relationBySessionId.get(sessionId);
+  }
+
+  private buildReceivedMessageEntry(message: SessionMessagePayload): ReceivedMessageEntry {
+    const context = this.getIncomingMessageIndexContext(message.source, message.target);
+    return {
+      messageId: message.messageId,
+      source: context.source,
+      target: context.target,
+      body: message.body,
+      sentAt: message.sentAt,
+      receivedAt: new Date().toISOString(),
+      ...(message.requestResponse === undefined
+        ? {}
+        : { requestResponse: message.requestResponse }),
+      ...(message.sourceToolCallId === undefined
+        ? {}
+        : { sourceToolCallId: message.sourceToolCallId }),
+      ...(context.relation === undefined ? {} : { relation: context.relation }),
+    };
+  }
+
+  private getIncomingMessageIndexContext(
+    sourceSessionId: string,
+    targetSessionId: string,
+  ): IncomingMessageIndexContext {
+    const fallback = {
+      source: buildReceivedMessageEndpoint(sourceSessionId),
+      target: buildReceivedMessageEndpoint(targetSessionId),
+    };
+    return (
+      withSessionIndex(this.indexPath, { mode: "read", required: false }, ({ db }) => {
+        const source = getSessionById(db, sourceSessionId);
+        const target = getSessionById(db, targetSessionId);
+        const currentSessionId = this.connection.currentSessionId;
+        const relationBySessionId = currentSessionId
+          ? new Map(getLineageRelationMap(db, currentSessionId))
+          : new Map<string, SessionLineageRelation>();
+        const relation = relationBySessionId.get(sourceSessionId);
+
+        if (currentSessionId) {
+          this.replaceCachedRelations(relationBySessionId);
+          if (!this.relationBySessionId.has(sourceSessionId)) {
+            this.relationBySessionId.set(sourceSessionId, undefined);
+          }
+        }
+
+        return {
+          source: buildReceivedMessageEndpoint(sourceSessionId, source),
+          target: buildReceivedMessageEndpoint(targetSessionId, target),
+          ...(relation === undefined ? {} : { relation }),
+        };
+      }) ?? fallback
+    );
+  }
+
+  private refreshCachedRelations(currentSessionId: string): void {
+    this.replaceCachedRelations(getRelationMapForSession(this.indexPath, currentSessionId));
+  }
+
+  private replaceCachedRelations(
+    nextRelations: Map<string, SessionLineageRelation | undefined>,
+  ): void {
+    const previousRelations = this.relationBySessionId;
+
+    for (const [sessionId, relation] of previousRelations) {
+      if (relation === undefined && !nextRelations.has(sessionId)) {
+        nextRelations.set(sessionId, undefined);
+      }
+    }
+
+    this.relationBySessionId = nextRelations;
+  }
+}
+
+class BrokerConnection implements ActiveSessionBrokerConnection {
+  private client: SessionMessagingClient | undefined;
+  private sessionId: string | undefined;
+  private active = false;
+  private reconnectTimer: NodeJS.Timeout | undefined;
+  private reconnectDelayIndex = 0;
+  private connectPromise: Promise<void> | undefined;
+
+  constructor(
+    private readonly onIncoming: (requestId: string, message: SessionMessagePayload) => void,
+  ) {}
+
+  get currentSessionId(): string | undefined {
+    return this.sessionId;
+  }
+
+  async start(sessionId: string): Promise<void> {
+    this.active = true;
+    this.sessionId = sessionId;
+    await this.ensureConnectedNow();
+  }
+
+  stop(): void {
+    this.active = false;
+    this.sessionId = undefined;
+    this.clearReconnectTimer();
+    this.client?.disconnect();
+    this.client = undefined;
+    this.connectPromise = undefined;
+  }
+
+  async listSessionIds(): Promise<string[]> {
+    await this.ensureConnectedNow();
+    return this.requireClient().listSessionIds();
+  }
+
+  async sendMessage(options: {
+    messageId: string;
+    target: string;
+    body: string;
+    sentAt: string;
+    requestResponse?: boolean | undefined;
+    sourceToolCallId?: string | undefined;
+  }): Promise<SessionMessageSendResult> {
+    await this.ensureConnectedNow();
+    return this.requireClient().sendMessage(options);
+  }
+
+  acknowledgeIncoming(
+    requestId: string,
+    messageId: string,
+    result: { delivered: true } | { delivered: false; error: string },
+  ): void {
+    try {
+      this.requireClient().acknowledgeIncoming(requestId, messageId, result);
+    } catch {}
+  }
+
+  private async ensureConnectedNow(): Promise<void> {
+    if (this.client?.isConnected) {
+      return;
+    }
+    if (!this.active || !this.sessionId) {
+      throw new Error("Session messaging is not active.");
+    }
+    this.clearReconnectTimer();
+
+    if (!this.connectPromise) {
+      this.connectPromise = this.connect().finally(() => {
+        this.connectPromise = undefined;
+      });
+    }
+
+    try {
+      await this.connectPromise;
+    } catch (error) {
+      this.scheduleReconnect();
+      throw error;
+    }
+  }
+
+  private async connect(): Promise<void> {
+    const sessionId = this.sessionId;
+    if (!sessionId) {
+      throw new Error("Session messaging is not active.");
+    }
+
+    this.client?.disconnect();
+    this.client = undefined;
+
+    await spawnSessionMessagingBrokerIfNeeded();
+    const client = new SessionMessagingClient();
+    client.on(INCOMING_SESSION_MESSAGE_EVENT, this.onIncoming);
+    client.on("disconnect", () => {
+      if (this.client === client) {
+        this.client = undefined;
+        this.scheduleReconnect();
+      }
+    });
+
+    await client.connect(sessionId);
+    this.client = client;
+    this.reconnectDelayIndex = 0;
+  }
+
+  private scheduleReconnect(): void {
+    if (!this.active || this.reconnectTimer) {
+      return;
+    }
+
+    const delay = RECONNECT_DELAYS_MS[this.reconnectDelayIndex] ?? 30_000;
+    this.reconnectDelayIndex = Math.min(
+      this.reconnectDelayIndex + 1,
+      RECONNECT_DELAYS_MS.length - 1,
+    );
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = undefined;
+      this.ensureConnectedNow().catch(() => {});
+    }, delay);
+  }
+
+  private clearReconnectTimer(): void {
+    if (!this.reconnectTimer) {
+      return;
+    }
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = undefined;
+  }
+
+  private requireClient(): SessionMessagingClient {
+    if (!this.client?.isConnected) {
+      throw new Error("Session messaging is not connected.");
+    }
+    return this.client;
+  }
+}
+
+function buildReceivedMessageEndpoint(
+  sessionId: string,
+  session?: SessionLineageRow | undefined,
+): ReceivedMessageEndpoint {
+  const sessionName = session?.sessionName.trim();
+  return {
+    sessionId,
+    ...(sessionName ? { sessionName } : {}),
+    ...(session?.cwd ? { cwd: session.cwd } : {}),
+  };
+}
+
+function getRelationMapForSession(
+  indexPath: string,
+  sessionId: string,
+): Map<string, SessionLineageRelation | undefined> {
+  return (
+    withSessionIndex(
+      indexPath,
+      { mode: "read", required: false },
+      ({ db }) => new Map(getLineageRelationMap(db, sessionId)),
+    ) ?? new Map()
+  );
+}

package/extensions/session-messaging/pi/tools.ts

@@ -0,0 +1,92 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { SEND_MESSAGE_PARAMS, type SendMessageParams } from "./message-contracts.ts";
+import { formatSendMessageCall } from "./message-view.ts";
+import type { SessionMessagingService } from "./service.ts";
+
+export function registerSessionMessagingTools(
+  pi: ExtensionAPI,
+  service: SessionMessagingService,
+): void {
+  pi.registerTool({
+    name: "session_send_message",
+    label: "Send Message to Session",
+    description: "Send a message to another live pi session",
+    promptSnippet: "Send a message to another live pi session",
+    promptGuidelines: [
+      "Use session_search with live: true to discover targetable sessions. Usually it is best to exclude all other filters and simply get a list of all live sessions",
+    ],
+    parameters: SEND_MESSAGE_PARAMS,
+    renderCall(args, theme, context) {
+      const component = (context.lastComponent as Text | undefined) ?? new Text("", 0, 0);
+      component.setText(
+        formatSendMessageCall(
+          args,
+          context.expanded,
+          "sending",
+          theme,
+          service.getCachedRelationTo(args?.session),
+        ),
+      );
+      return component;
+    },
+    renderResult(result, _options, theme, context) {
+      if (!context.isError) {
+        return new Text("", 0, 0);
+      }
+
+      const output = getFirstText(result);
+      return new Text(output ? `\n${theme.fg("error", output)}` : "", 0, 0);
+    },
+    async execute(toolCallId, params: SendMessageParams, _signal, _onUpdate, _ctx) {
+      const target = params.session.trim();
+      if (!target) {
+        throw new Error("session_send_message requires a target session id.");
+      }
+      if (target.startsWith("@session:")) {
+        throw new Error("Use the bare session UUID, not an @session token.");
+      }
+
+      const body = params.message.trim();
+      if (!body) {
+        throw new Error("session_send_message requires a non-empty message.");
+      }
+
+      try {
+        const result = await service.sendMessage({
+          target,
+          body,
+          requestResponse: params.requestResponse,
+          sourceToolCallId: toolCallId,
+        });
+        if (!result.delivered) {
+          throw new Error(result.error ?? "Message was not delivered.");
+        }
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Message delivered to ${target}.`,
+            },
+          ],
+          details: {
+            delivered: true,
+            messageId: result.messageId,
+            targetSessionId: target,
+          },
+        };
+      } catch (error) {
+        throw new Error(formatError(error));
+      }
+    },
+  });
+}
+
+function getFirstText(result: { content: Array<{ type: string; text?: string }> }): string {
+  return result.content.find((item) => item.type === "text")?.text ?? "";
+}
+
+function formatError(error: unknown): string {
+  return error instanceof Error && error.message.trim() ? error.message : String(error);
+}

package/extensions/session-messaging.ts

@@ -0,0 +1,30 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { IncomingSessionMessageRuntime } from "./session-messaging/pi/incoming-runtime.ts";
+import { registerSessionMessagingRenderer } from "./session-messaging/pi/renderer.ts";
+import { SessionMessagingService } from "./session-messaging/pi/service.ts";
+import { registerSessionMessagingTools } from "./session-messaging/pi/tools.ts";
+import { loadSettings } from "./shared/settings.ts";
+
+export default function sessionMessagingExtension(pi: ExtensionAPI): void {
+  const settings = loadSettings();
+  const incomingRuntime = new IncomingSessionMessageRuntime(pi);
+  const service = new SessionMessagingService(
+    settings.index.path,
+    incomingRuntime,
+    pi.appendEntry.bind(pi),
+  );
+
+  pi.on("session_start", async (_event, ctx) => {
+    incomingRuntime.replayPending(ctx);
+    try {
+      await service.start(ctx);
+    } catch {}
+  });
+
+  pi.on("session_shutdown", () => {
+    service.stop();
+  });
+
+  registerSessionMessagingTools(pi, service);
+  registerSessionMessagingRenderer(pi);
+}