@ctliz/agent-intercom-pi 0.11.0-connect.2

package/team.ts

@@ -0,0 +1,192 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getAgentDirPath } from "./broker/paths.ts";
+import { bossSelfSessionError, resolveBossLiveSession, type BossTeamScope } from "./boss-team-scope.ts";
+
+export interface TeamSession {
+  id: string;
+  name?: string;
+  origin?: "local" | "remote";
+}
+
+interface StoredWorker {
+  id?: unknown;
+  runId?: unknown;
+  harness?: unknown;
+  role?: unknown;
+  state?: unknown;
+  owned?: unknown;
+  managerSessionId?: unknown;
+  intercomTarget?: unknown;
+}
+
+export interface TeamMember {
+  id: string;
+  target: string;
+  harness?: string;
+  role?: string;
+  state?: string;
+  connected: boolean;
+}
+
+export interface IntercomTeam {
+  teamId?: string;
+  self: { id: string; workerId?: string; isManager: boolean };
+  manager?: { target: string; connected: boolean };
+  controller?: { target: string; connected: boolean };
+  coworkers: TeamMember[];
+}
+
+/** Authorizes a read-only local inbox lookup using exact orchestrator ownership. */
+export function resolveManagedInboxSession(input: {
+  team: IntercomTeam;
+  sessions: TeamSession[];
+  requestedSession: string;
+}): TeamSession {
+  if (!input.team.self.isManager) {
+    throw new Error("Only a manager may inspect another session's pending-ask inbox");
+  }
+  const member = input.team.coworkers.find((entry) => entry.target === input.requestedSession);
+  if (!member) {
+    throw new Error(`Pending-ask inbox access denied for "${input.requestedSession}"; select an owned coworker target returned by intercom_team`);
+  }
+  const liveSession = input.sessions.find((session) => session.id === input.requestedSession);
+  if (!liveSession) {
+    throw new Error(`Pending-ask inbox access denied for "${input.requestedSession}"; the owned coworker target must equal an exact connected stable session ID`);
+  }
+  if (liveSession.origin === "remote") {
+    throw new Error(`Pending-ask inbox "${input.requestedSession}" is remote and cannot be read from this host`);
+  }
+  return liveSession;
+}
+
+const LIVE_STATES = new Set(["provisioning", "running", "idle", "needs_attention", "stopping"]);
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function connectedTo(sessions: TeamSession[], target: string): boolean {
+  const normalized = target.toLowerCase();
+  return sessions.some((session) => session.id === target || session.name?.toLowerCase() === normalized);
+}
+
+async function readWorkers(agentDir: string): Promise<StoredWorker[]> {
+  try {
+    const parsed = JSON.parse(await readFile(join(agentDir, "intercom", "orchestrator", "workers.json"), "utf8")) as { workers?: unknown };
+    return Array.isArray(parsed.workers) ? parsed.workers as StoredWorker[] : [];
+  } catch {
+    return [];
+  }
+}
+
+export async function resolveIntercomTeam(input: {
+  selfId: string;
+  sessions: TeamSession[];
+  env?: NodeJS.ProcessEnv;
+  agentDir?: string;
+}): Promise<IntercomTeam> {
+  const env = input.env ?? process.env;
+  const workers = await readWorkers(input.agentDir ?? getAgentDirPath());
+  const workerId = stringValue(env.AGENT_INTERCOM_WORKER_ID);
+  const runId = stringValue(env.AGENT_INTERCOM_RUN_ID);
+  const current = workerId
+    ? workers.find((worker) => stringValue(worker.id) === workerId && (!runId || stringValue(worker.runId) === runId))
+    : undefined;
+  const managerTarget = stringValue(current?.managerSessionId) ?? stringValue(env.AGENT_INTERCOM_MANAGER_TARGET) ?? stringValue(env.AGENT_INTERCOM_MANAGER_SESSION_ID);
+  const teamId = managerTarget ?? input.selfId;
+  const isManager = !managerTarget;
+  const coworkers = workers
+    .filter((worker) => worker.owned === true)
+    .filter((worker) => stringValue(worker.managerSessionId) === teamId)
+    .filter((worker) => LIVE_STATES.has(stringValue(worker.state) ?? ""))
+    .filter((worker) => stringValue(worker.id) !== workerId)
+    .map((worker): TeamMember | undefined => {
+      const id = stringValue(worker.id);
+      if (!id) return undefined;
+      const target = stringValue(worker.intercomTarget) ?? id;
+      return {
+        id,
+        target,
+        ...(stringValue(worker.harness) ? { harness: stringValue(worker.harness) } : {}),
+        ...(stringValue(worker.role) ? { role: stringValue(worker.role) } : {}),
+        ...(stringValue(worker.state) ? { state: stringValue(worker.state) } : {}),
+        connected: connectedTo(input.sessions, target),
+      };
+    })
+    .filter((member): member is TeamMember => Boolean(member));
+
+  return {
+    teamId,
+    self: { id: input.selfId, ...(workerId ? { workerId } : {}), isManager },
+    manager: managerTarget
+      ? { target: managerTarget, connected: connectedTo(input.sessions, managerTarget) }
+      : { target: input.selfId, connected: true },
+    coworkers,
+  };
+}
+
+export function resolveBossIntercomTeam(input: {
+  selfId: string;
+  sessions: TeamSession[];
+  scope: BossTeamScope;
+}): IntercomTeam {
+  const { scope } = input;
+  if (!scope.present || !scope.valid || !scope.restricted) {
+    throw new Error("error" in scope ? scope.error : "Boss team-only metadata is not active");
+  }
+  const selfError = bossSelfSessionError(scope, input.selfId);
+  if (selfError) throw new Error(selfError);
+
+  const isManager = scope.role === "manager";
+  const managerSession = resolveBossLiveSession(input.sessions, scope.managerTarget);
+  const controllerSession = resolveBossLiveSession(input.sessions, scope.controllerTarget);
+  const manager = isManager
+    ? { target: input.selfId, connected: true }
+    : managerSession
+      ? { target: scope.managerTarget, connected: true }
+      : undefined;
+  const controller = isManager && controllerSession
+    ? { target: scope.controllerTarget, connected: true }
+    : undefined;
+  const excludedIds = new Set([input.selfId, managerSession?.id, controllerSession?.id].filter((id): id is string => Boolean(id)));
+  const coworkerIds = new Set<string>();
+  const coworkers: TeamMember[] = [];
+  for (const target of scope.teamTargets) {
+    const session = resolveBossLiveSession(input.sessions, target);
+    if (!session || excludedIds.has(session.id) || coworkerIds.has(session.id)) continue;
+    coworkerIds.add(session.id);
+    coworkers.push({ id: session.id, target, connected: true });
+  }
+
+  return {
+    ...(manager ? { teamId: manager.target } : {}),
+    self: { id: input.selfId, isManager },
+    ...(manager ? { manager } : {}),
+    ...(controller ? { controller } : {}),
+    coworkers,
+  };
+}
+
+export function formatIntercomTeam(team: IntercomTeam): string {
+  const manager = team.manager
+    ? `${team.manager.target} [${team.manager.connected ? "connected" : "not connected"}]`
+    : "unknown";
+  const lines = [
+    `Manager: ${manager}`,
+    `You: ${team.self.id}${team.self.isManager ? " [manager]" : ""}`,
+  ];
+  if (team.controller) {
+    lines.push(`Controller: ${team.controller.target} [connected]`);
+  }
+  if (team.coworkers.length === 0) {
+    lines.push("Coworkers: none");
+  } else {
+    lines.push("Coworkers:");
+    for (const coworker of team.coworkers) {
+      const metadata = [coworker.harness, coworker.role, coworker.state].filter(Boolean).join(", ");
+      lines.push(`- ${coworker.id} target=${coworker.target}${metadata ? ` (${metadata})` : ""} [${coworker.connected ? "connected" : "not connected"}]`);
+    }
+  }
+  return lines.join("\n");
+}

package/types.ts

@@ -0,0 +1,183 @@
+import type { BrokerCapabilityAdvertisement } from "@ctliz/agent-intercom-core/boss";
+import type { IntercomCommonControlEnvelope } from "./control.ts";
+import type {
+  BossParticipantRegistrationMetadata,
+  BossSessionMetadata,
+} from "./broker/boss-adapter.ts";
+
+export interface SessionInfo {
+  id: string;
+  name?: string;
+  cwd: string;
+  model: string;
+  pid: number;
+  startedAt: number;
+  lastActivity: number;
+  status?: string;
+  peerUid?: number;
+  trustedLocal?: boolean;
+  origin?: "local" | "remote";
+  remoteHostId?: string;
+  parentSessionId?: string;
+  rootSessionId?: string;
+  generation?: number;
+  canDelegate?: boolean;
+  depth?: number;
+  maxDepth?: number;
+  maxChildren?: number;
+  /** Broker-owned live binding; never accepted from SessionRegistration. */
+  boss?: BossSessionMetadata;
+}
+
+export interface Message {
+  id: string;
+  timestamp: number;
+  replyTo?: string;
+  expectsReply?: boolean;
+  content: {
+    text: string;
+    attachments?: Attachment[];
+    control?: IntercomCommonControlEnvelope;
+  };
+}
+
+export interface Attachment {
+  type: "file" | "snippet" | "context";
+  name: string;
+  content: string;
+  language?: string;
+}
+
+export type SessionRegistration = Omit<
+  SessionInfo,
+  "id" | "peerUid" | "trustedLocal" | "origin" | "remoteHostId" | "parentSessionId" | "rootSessionId" | "generation" | "canDelegate" | "depth" | "maxDepth" | "maxChildren"
+  | "boss"
+> & {
+  /** Ephemeral identity shared only by reconnects from one live runtime. */
+  runtimeInstanceId?: string;
+  /** Optional broker-authority metadata. Rejected unless boss-run-v1 is exactly negotiated. */
+  boss?: BossParticipantRegistrationMetadata;
+};
+
+export interface RemoteEnrollmentAccess {
+  enrollmentToken: string;
+}
+
+export interface RemoteSessionAccess {
+  sessionCredential: string;
+  sessionId: string;
+  generation: number;
+}
+
+export type RemoteRegistrationAccess = RemoteEnrollmentAccess | RemoteSessionAccess;
+
+export interface RemoteAccessMetadata {
+  origin: "remote";
+  remoteHostId: string;
+  parentSessionId: string;
+  rootSessionId: string;
+  generation: number;
+  canDelegate: boolean;
+  depth: number;
+  maxDepth: number;
+  maxChildren: number;
+  sessionCredential?: string;
+}
+
+export interface RemotePrincipalSummary {
+  id: string;
+  name: string;
+  parentSessionId: string;
+  rootSessionId: string;
+  remoteHostId: string;
+  generation: number;
+  policy: "remote-tree";
+  canDelegate: boolean;
+  depth: number;
+  maxDepth: number;
+  maxChildren: number;
+  state: "active" | "revoked";
+  expiresAt: number;
+  createdAt: number;
+  updatedAt: number;
+  connected: boolean;
+}
+
+export interface RemoteAccessContract {
+  feature: "remote-access-v1";
+  policySemanticsVersion: number;
+  policySemanticsHash: string;
+}
+
+export type DeliveryFailureCode =
+  | "INVALID_MESSAGE"
+  | "CONTROL_DISPATCH_UNAVAILABLE"
+  | "SESSION_NOT_FOUND"
+  | "AMBIGUOUS_TARGET"
+  | "SENDER_NOT_FOUND"
+  | "INVALID_REPLY_TARGET"
+  | "MUTUAL_ASK"
+  | "ASK_ALREADY_PENDING"
+  | "DUPLICATE_MESSAGE_ID"
+  | "CONFLICTING_MESSAGE_ID"
+  | "TOO_MANY_PENDING_DELIVERIES"
+  | "TOO_MANY_PENDING_ASKS"
+  | "RECIPIENT_DISCONNECTED"
+  | "SENDER_DISCONNECTED"
+  | "DELIVERY_TIMEOUT";
+
+export type BrokerErrorCode =
+  | "PROTOCOL_MISMATCH"
+  | "INVALID_REQUEST"
+  | "SESSION_ID_IN_USE"
+  | "ACCESS_DENIED"
+  | "BOSS_FEATURE_UNAVAILABLE"
+  | "REMOTE_ACCESS_INCOMPATIBLE"
+  | "RATE_LIMITED"
+  | "TOO_MANY_SESSIONS";
+
+export type AskCancellationReason =
+  | "cancelled"
+  | "expired"
+  | "delivery_failed"
+  | "session_disconnected"
+  | "authorization_revoked";
+
+export type ClientMessage =
+  | { type: "health"; requestId: string; stateId?: string }
+  | { type: "register"; protocol: string; version: number; session: SessionRegistration; sessionId?: string; stateId?: string; access?: RemoteRegistrationAccess; scopeId?: string }
+  | { type: "access_control"; requestId: string; adminToken: string; action: "issue_enrollment"; enrollment: { name: string; parentSessionId: string; rootSessionId: string; remoteHostId: string; ttlMs?: number; expiresAt?: number; canDelegate?: boolean; maxDepth?: number; maxChildren?: number } }
+  | { type: "access_control"; requestId: string; adminToken: string; action: "revoke_subtree"; principalId: string }
+  | { type: "access_control"; requestId: string; adminToken: string; action: "inspect_tree"; principalId: string }
+  | { type: "access_control"; requestId: string; adminToken: string; action: "adopt_subtree"; principalId: string; newParentSessionId: string }
+  | { type: "access_control"; requestId: string; access: RemoteSessionAccess; action: "issue_child_enrollment"; enrollment: { name: string; ttlMs?: number; expiresAt?: number; canDelegate?: boolean; maxDepth?: number; maxChildren?: number } }
+  | { type: "access_control"; requestId: string; access: RemoteSessionAccess; action: "inspect_tree"; principalId?: string }
+  | { type: "unregister"; preserveAsks?: boolean }
+  | { type: "list"; requestId: string }
+  | { type: "send"; to: string; message: Message }
+  | { type: "message_received"; deliveryId: string }
+  | { type: "message_rejected"; deliveryId: string; code: "CONFLICTING_MESSAGE_ID"; reason: string }
+  | { type: "defer_ask"; requestId: string; messageId: string }
+  | { type: "cancel_ask"; requestId: string; messageId: string }
+  | { type: "presence"; name?: string; status?: string; model?: string };
+
+export type BrokerMessage =
+  | { type: "health_ok"; requestId: string; protocol: string; version: number; endpoint: "local" | "remote"; capabilities?: BrokerCapabilityAdvertisement; remoteAccess?: RemoteAccessContract }
+  | { type: "registered"; sessionId: string; protocol: string; version: number; capabilities?: BrokerCapabilityAdvertisement; boss?: BossSessionMetadata; remoteAccess?: RemoteAccessContract; access?: RemoteAccessMetadata }
+  | { type: "access_control_result"; requestId: string; action: "issue_enrollment"; enrollmentToken: string; expiresAt: number }
+  | { type: "access_control_result"; requestId: string; action: "revoke_subtree"; changedPrincipalIds: string[] }
+  | { type: "access_control_result"; requestId: string; action: "inspect_tree"; principals: RemotePrincipalSummary[] }
+  | { type: "access_control_result"; requestId: string; action: "adopt_subtree"; principals: RemotePrincipalSummary[] }
+  | { type: "access_control_result"; requestId: string; action: "issue_child_enrollment"; enrollmentToken: string; expiresAt: number; parentSessionId: string }
+  | { type: "sessions"; requestId: string; sessions: SessionInfo[] }
+  | { type: "message"; deliveryId: string; from: SessionInfo; message: Message }
+  | { type: "presence_update"; session: SessionInfo }
+  | { type: "session_joined"; session: SessionInfo }
+  | { type: "session_left"; sessionId: string }
+  | { type: "error"; code: BrokerErrorCode; error: string }
+  | { type: "delivery_accepted"; messageId: string; deliveryId: string }
+  | { type: "delivered"; messageId: string; deliveryId: string }
+  | { type: "delivery_failed"; messageId: string; accepted: boolean; code: DeliveryFailureCode; reason: string }
+  | { type: "ask_deferred"; messageId: string; fromSessionId: string }
+  | { type: "ask_cancelled"; messageId: string; fromSessionId: string; reason: AskCancellationReason }
+  | { type: "ask_control_result"; requestId: string; action: "defer" | "cancel"; messageId: string; applied: boolean };

package/ui/compose.ts

@@ -0,0 +1,229 @@
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import type { KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
+import type { IntercomClient } from "../broker/client.ts";
+import type { SessionInfo } from "../types.ts";
+import { sanitizeDisplayText } from "./session-identity.ts";
+
+export interface ComposeResult {
+  sent: boolean;
+  messageId?: string;
+  text?: string;
+}
+
+export class ComposeOverlay implements Component {
+  private tui: TUI;
+  private theme: Theme;
+  private keybindings: KeybindingsManager;
+  private target: SessionInfo;
+  private targetLabel: string;
+  private client: IntercomClient;
+  private done: (result: ComposeResult) => void;
+  private inputBuffer: string = "";
+  private pasteBuffer: string | null = null;
+  private sending: boolean = false;
+  private error: string | null = null;
+
+  constructor(
+    tui: TUI,
+    theme: Theme,
+    keybindings: KeybindingsManager,
+    target: SessionInfo,
+    targetLabel: string,
+    client: IntercomClient,
+    done: (result: ComposeResult) => void,
+  ) {
+    this.tui = tui;
+    this.theme = theme;
+    this.keybindings = keybindings;
+    this.target = target;
+    this.targetLabel = targetLabel;
+    this.client = client;
+    this.done = done;
+  }
+
+  invalidate(): void {}
+
+  handleInput(data: string): void {
+    if (this.sending) return;
+
+    if (this.pasteBuffer !== null) {
+      this.consumePaste(data);
+      return;
+    }
+
+    const pasteStart = data.indexOf("\x1b[200~");
+    if (pasteStart !== -1) {
+      const beforePaste = data.slice(0, pasteStart);
+      if (beforePaste) this.insertPrintable(beforePaste);
+      this.pasteBuffer = "";
+      this.consumePaste(data.slice(pasteStart + 6));
+      return;
+    }
+
+    if (this.keybindings.matches(data, "tui.select.cancel")) {
+      this.done({ sent: false });
+      return;
+    }
+
+    if (this.keybindings.matches(data, "tui.input.newLine")) {
+      this.inputBuffer += "\n";
+      this.tui.requestRender();
+      return;
+    }
+
+    if (
+      this.keybindings.matches(data, "tui.input.submit")
+      || this.keybindings.matches(data, "tui.select.confirm")
+    ) {
+      if (this.inputBuffer.trim()) {
+        this.sendMessage();
+      }
+      return;
+    }
+
+    if (this.keybindings.matches(data, "tui.editor.deleteCharBackward")) {
+      this.inputBuffer = [...this.inputBuffer].slice(0, -1).join("");
+      this.tui.requestRender();
+      return;
+    }
+
+    if (data.startsWith("\x1b")) return;
+    this.insertPrintable(data);
+  }
+
+  private consumePaste(data: string): void {
+    if (this.pasteBuffer === null) return;
+    const pasteEnd = data.indexOf("\x1b[201~");
+    if (pasteEnd === -1) {
+      this.pasteBuffer += data;
+      return;
+    }
+
+    const pastedText = this.pasteBuffer + data.slice(0, pasteEnd);
+    this.pasteBuffer = null;
+    this.inputBuffer += this.normalizeInput(pastedText, true);
+    this.tui.requestRender();
+
+    const remaining = data.slice(pasteEnd + 6);
+    if (remaining) this.handleInput(remaining);
+  }
+
+  private normalizeInput(data: string, preserveNewlines = false): string {
+    return data
+      .replace(/\r\n?/g, "\n")
+      .replace(/\t/g, "    ")
+      .split("")
+      .filter(character => {
+        if (preserveNewlines && character === "\n") return true;
+        const code = character.charCodeAt(0);
+        return code >= 32 && code !== 127 && !(code >= 128 && code <= 159);
+      })
+      .join("");
+  }
+
+  private insertPrintable(data: string): void {
+    const printable = this.normalizeInput(data);
+    if (!printable) return;
+    this.inputBuffer += printable;
+    this.tui.requestRender();
+  }
+
+  private async sendMessage(): Promise<void> {
+    this.sending = true;
+    this.error = null;
+    this.tui.requestRender();
+
+    try {
+      const result = await this.client.send(this.target.id, {
+        text: this.inputBuffer.trim(),
+      });
+
+      if (!result.delivered) {
+        this.error = sanitizeDisplayText(
+          result.reason,
+          "Message not delivered. Session may not exist or has disconnected.",
+        );
+        this.sending = false;
+        this.tui.requestRender();
+        return;
+      }
+
+      this.done({
+        sent: true,
+        messageId: result.id,
+        text: this.inputBuffer.trim(),
+      });
+    } catch (error) {
+      this.error = sanitizeDisplayText(error instanceof Error ? error.message : String(error), "Message failed");
+      this.sending = false;
+      this.tui.requestRender();
+    }
+  }
+
+  render(width: number): string[] {
+    const innerWidth = Math.max(1, Math.min(width, 72));
+    if (innerWidth === 1) {
+      return [this.theme.fg("accent", "│")];
+    }
+
+    const contentWidth = Math.max(0, innerWidth - 2);
+    const sendKeys = this.keybindings.getKeys("tui.input.submit");
+    const newlineKeys = this.keybindings.getKeys("tui.input.newLine");
+    const footer = `${sendKeys.join("/")}: Send • ${newlineKeys.join("/")}: New line • ${this.keybindings.getKeys("tui.select.cancel").join("/")}: Close`;
+    const border = (text: string) => this.theme.fg("accent", text);
+    const row = (text = "") => {
+      const clipped = truncateToWidth(text, contentWidth, "", true);
+      return `${border("│")}${clipped}${" ".repeat(Math.max(0, contentWidth - visibleWidth(clipped)))}${border("│")}`;
+    };
+
+    const lines: string[] = [];
+    const targetLabel = sanitizeDisplayText(
+      this.targetLabel,
+      sanitizeDisplayText(this.target.id, "Unknown session"),
+    );
+    const targetCwd = sanitizeDisplayText(this.target.cwd, "Unknown path");
+    const targetModel = sanitizeDisplayText(this.target.model, "Unknown model");
+    lines.push(border(`╭${"─".repeat(contentWidth)}╮`));
+    lines.push(row(this.theme.bold(` Send to: ${targetLabel}`)));
+    lines.push(row(this.theme.fg("dim", ` ${targetCwd} • ${targetModel}`)));
+    lines.push(border(`├${"─".repeat(contentWidth)}┤`));
+    lines.push(row());
+
+    if (this.sending) {
+      lines.push(row(this.theme.fg("dim", " Sending...")));
+    } else if (this.error) {
+      lines.push(row(this.theme.fg("error", ` Error: ${this.error}`)));
+      lines.push(row());
+      lines.push(...this.renderInputRows(contentWidth, row));
+    } else {
+      lines.push(...this.renderInputRows(contentWidth, row));
+    }
+
+    lines.push(row());
+    lines.push(border(`├${"─".repeat(contentWidth)}┤`));
+    lines.push(row(this.theme.fg("dim", ` ${footer}`)));
+    lines.push(border(`╰${"─".repeat(contentWidth)}╯`));
+
+    return lines;
+  }
+
+  private renderInputRows(contentWidth: number, row: (text?: string) => string): string[] {
+    const promptWidth = Math.min(3, contentWidth);
+    const textWidth = Math.max(1, contentWidth - promptWidth);
+    const logicalLines = this.inputBuffer.split("\n");
+    const rendered: string[] = [];
+
+    logicalLines.forEach((logicalLine, logicalIndex) => {
+      const wrapped = wrapTextWithAnsi(logicalLine, textWidth);
+      const visualLines = wrapped.length ? wrapped : [""];
+      visualLines.forEach((visualLine, visualIndex) => {
+        const isFirst = logicalIndex === 0 && visualIndex === 0;
+        const isLast = logicalIndex === logicalLines.length - 1 && visualIndex === visualLines.length - 1;
+        rendered.push(row(`${isFirst ? " > " : "   "}${visualLine}${isLast ? "█" : ""}`));
+      });
+    });
+
+    return rendered.slice(-8);
+  }
+}