pi-ca-leash 0.10.0

package/extensions/support.ts

@@ -0,0 +1,205 @@
+import type { BridgeTransportStatus } from "@pi-claude-code-agent/intercom-bridge";
+import type { SubagentRunRecord } from "@pi-claude-code-agent/subagents-backend";
+
+export interface DashboardState {
+  lastEvent: string;
+  lastEventAt: number;
+  lastRefreshedAt: number;
+}
+
+export interface AttentionLedgerEntry {
+  note: string;
+  lastNotifiedNote?: string;
+  acknowledgedNote?: string;
+  snoozedUntil?: number;
+}
+
+export interface AttentionLedger {
+  runs: Record<string, AttentionLedgerEntry>;
+}
+
+export interface AttentionView {
+  run: SubagentRunRecord;
+  status: "active" | "acked" | "snoozed";
+  snoozedUntil?: number;
+}
+
+export interface AttentionReconciliation {
+  ledger: AttentionLedger;
+  notify: SubagentRunRecord[];
+  active: AttentionView[];
+}
+
+export function createDashboardState(lastEvent: string, now = Date.now()): DashboardState {
+  return {
+    lastEvent,
+    lastEventAt: now,
+    lastRefreshedAt: now,
+  };
+}
+
+export function recordDashboardEvent(state: DashboardState, lastEvent: string, now = Date.now()): void {
+  state.lastEvent = lastEvent;
+  state.lastEventAt = now;
+  state.lastRefreshedAt = now;
+}
+
+export function recordDashboardRefresh(state: DashboardState, now = Date.now()): void {
+  state.lastRefreshedAt = now;
+}
+
+export function detectConnectivityTransition(previous: boolean | undefined, next: boolean): "connected" | "disconnected" | undefined {
+  if (previous === undefined || previous === next) {
+    return undefined;
+  }
+  return next ? "connected" : "disconnected";
+}
+
+export function shouldRebindTransport(status: BridgeTransportStatus | undefined): boolean {
+  if (!status) {
+    return false;
+  }
+  return status.boundPeers > status.connectedPeers;
+}
+
+export function shouldSkipBackgroundRefresh(state: DashboardState, now: number, minIntervalMs: number): boolean {
+  return (now - state.lastRefreshedAt) < minIntervalMs;
+}
+
+export interface WidgetSignatureInput {
+  peerRows: Array<{
+    name: string;
+    state: string;
+    activity: string;
+    lastUpdateAt?: string;
+    model?: string;
+    contextPercentage?: number;
+  }>;
+  transportDegraded: boolean;
+  lastEvent: string;
+}
+
+// Stable string fingerprint of visible widget content.
+export function computeWidgetSignature(input: WidgetSignatureInput): string {
+  return JSON.stringify(input);
+}
+
+export function createAttentionLedger(): AttentionLedger {
+  return { runs: {} };
+}
+
+export function reconcileAttentionLedger(
+  ledger: AttentionLedger,
+  runs: SubagentRunRecord[],
+  now = Date.now(),
+): AttentionReconciliation {
+  const nextRuns: AttentionLedger["runs"] = {};
+  const notify: SubagentRunRecord[] = [];
+  const active: AttentionView[] = [];
+
+  for (const run of runs.filter((item) => hasAttentionNote(item.note))) {
+    const note = run.note ?? "Needs attention";
+    const previous = ledger.runs[run.runId];
+    const entry: AttentionLedgerEntry = previous?.note === note
+      ? { ...previous, note }
+      : { note };
+
+    if (entry.snoozedUntil && entry.snoozedUntil <= now) {
+      delete entry.snoozedUntil;
+      delete entry.lastNotifiedNote;
+    }
+
+    const view = buildAttentionView(run, entry, now);
+
+    if (view.status === "active" && entry.lastNotifiedNote !== note) {
+      entry.lastNotifiedNote = note;
+      notify.push(run);
+    }
+
+    nextRuns[run.runId] = entry;
+    active.push(view);
+  }
+
+  active.sort((a, b) => b.run.updatedAt.localeCompare(a.run.updatedAt));
+
+  return {
+    ledger: { runs: nextRuns },
+    notify,
+    active,
+  };
+}
+
+export function acknowledgeAttention(ledger: AttentionLedger, runId: string): AttentionLedger {
+  const entry = ledger.runs[runId];
+  if (!entry) {
+    return ledger;
+  }
+  return {
+    runs: {
+      ...ledger.runs,
+      [runId]: {
+        ...entry,
+        acknowledgedNote: entry.note,
+        snoozedUntil: undefined,
+      },
+    },
+  };
+}
+
+export function snoozeAttention(ledger: AttentionLedger, runId: string, snoozedUntil: number): AttentionLedger {
+  const entry = ledger.runs[runId];
+  if (!entry) {
+    return ledger;
+  }
+  return {
+    runs: {
+      ...ledger.runs,
+      [runId]: {
+        ...entry,
+        snoozedUntil,
+      },
+    },
+  };
+}
+
+export function listAttentionViews(
+  ledger: AttentionLedger,
+  runs: SubagentRunRecord[],
+  now = Date.now(),
+): AttentionView[] {
+  return runs
+    .filter((run) => hasAttentionNote(run.note))
+    .map((run) => {
+      const note = run.note ?? "Needs attention";
+      const previous = ledger.runs[run.runId];
+      const entry = previous?.note === note ? { ...previous, note } : { note };
+      return buildAttentionView(run, entry, now);
+    })
+    .sort((a, b) => b.run.updatedAt.localeCompare(a.run.updatedAt));
+}
+
+export function describeAttentionState(view: AttentionView, now = Date.now()): string {
+  if (view.status === "acked") {
+    return "acked";
+  }
+  if (view.status === "snoozed" && view.snoozedUntil) {
+    const remainingMs = Math.max(0, view.snoozedUntil - now);
+    const remainingMinutes = Math.max(1, Math.ceil(remainingMs / 60_000));
+    return `snoozed ${remainingMinutes}m`;
+  }
+  return "active";
+}
+
+export function hasAttentionNote(note: string | undefined): boolean {
+  return Boolean(note && note.toLowerCase().includes("needs attention"));
+}
+
+function buildAttentionView(run: SubagentRunRecord, entry: AttentionLedgerEntry, now: number): AttentionView {
+  const acknowledged = entry.acknowledgedNote === entry.note;
+  const snoozed = !acknowledged && (entry.snoozedUntil ?? 0) > now;
+  return {
+    run,
+    status: acknowledged ? "acked" : snoozed ? "snoozed" : "active",
+    snoozedUntil: entry.snoozedUntil,
+  };
+}

package/extensions/tool-inputs.test.ts

@@ -0,0 +1,45 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { parseSubagentRunToolInput, parseTeamSpawnToolInput } from "./tool-inputs.ts";
+
+test("parseSubagentRunToolInput applies defaults and parses codex driver", () => {
+  assert.deepEqual(parseSubagentRunToolInput({
+    task: "  do work  ",
+    driver: "codex-cli",
+    async: true,
+  }), {
+    task: "do work",
+    name: "claude-subagent",
+    prompt: "You are delegated worker. Be concise and execution-focused.",
+    driver: "codex-cli",
+    model: undefined,
+    cwd: undefined,
+    async: true,
+  });
+});
+
+test("parseSubagentRunToolInput rejects missing task and invalid driver", () => {
+  assert.throws(() => parseSubagentRunToolInput({}), /task required/);
+  assert.throws(() => parseSubagentRunToolInput({ task: "x", driver: "wat" }), /driver must be claude-sdk or codex-cli/);
+});
+
+test("parseTeamSpawnToolInput trims strings and parses claude driver", () => {
+  assert.deepEqual(parseTeamSpawnToolInput({
+    name: " worker ",
+    prompt: " hello ",
+    driver: "claude-sdk",
+    model: " o4-mini ",
+    cwd: " /tmp ",
+  }), {
+    name: "worker",
+    prompt: "hello",
+    driver: "claude-sdk",
+    model: "o4-mini",
+    cwd: "/tmp",
+  });
+});
+
+test("parseTeamSpawnToolInput rejects missing required fields and invalid driver", () => {
+  assert.throws(() => parseTeamSpawnToolInput({ name: "worker" }), /name and prompt required/);
+  assert.throws(() => parseTeamSpawnToolInput({ name: "worker", prompt: "hi", driver: "wat" }), /driver must be claude-sdk or codex-cli/);
+});

package/extensions/tool-inputs.ts

@@ -0,0 +1,79 @@
+import { parseRuntimeDriverName } from "./runtime-driver.js";
+
+export interface ParsedSubagentRunToolInput {
+  task: string;
+  name: string;
+  prompt: string;
+  driver?: "claude-sdk" | "codex-cli";
+  model?: string;
+  cwd?: string;
+  async: boolean;
+}
+
+export interface ParsedTeamSpawnToolInput {
+  name: string;
+  prompt: string;
+  driver?: "claude-sdk" | "codex-cli";
+  model?: string;
+  cwd?: string;
+}
+
+const DEFAULT_SUBAGENT_NAME = "claude-subagent";
+const DEFAULT_SUBAGENT_PROMPT = "You are delegated worker. Be concise and execution-focused.";
+
+export function parseSubagentRunToolInput(input: {
+  task?: unknown;
+  name?: unknown;
+  prompt?: unknown;
+  driver?: unknown;
+  model?: unknown;
+  cwd?: unknown;
+  async?: unknown;
+}): ParsedSubagentRunToolInput {
+  const task = String(input.task ?? "").trim();
+  if (!task) {
+    throw new Error("task required");
+  }
+
+  const driver = input.driver == null ? undefined : parseRuntimeDriverName(input.driver);
+  if (input.driver != null && !driver) {
+    throw new Error("driver must be claude-sdk or codex-cli");
+  }
+
+  return {
+    task,
+    name: typeof input.name === "string" ? input.name.trim() || DEFAULT_SUBAGENT_NAME : DEFAULT_SUBAGENT_NAME,
+    prompt: typeof input.prompt === "string" ? input.prompt.trim() || DEFAULT_SUBAGENT_PROMPT : DEFAULT_SUBAGENT_PROMPT,
+    driver,
+    model: typeof input.model === "string" ? input.model.trim() || undefined : undefined,
+    cwd: typeof input.cwd === "string" ? input.cwd.trim() || undefined : undefined,
+    async: input.async === true,
+  };
+}
+
+export function parseTeamSpawnToolInput(input: {
+  name?: unknown;
+  prompt?: unknown;
+  driver?: unknown;
+  model?: unknown;
+  cwd?: unknown;
+}): ParsedTeamSpawnToolInput {
+  const name = String(input.name ?? "").trim();
+  const prompt = String(input.prompt ?? "").trim();
+  if (!name || !prompt) {
+    throw new Error("name and prompt required");
+  }
+
+  const driver = input.driver == null ? undefined : parseRuntimeDriverName(input.driver);
+  if (input.driver != null && !driver) {
+    throw new Error("driver must be claude-sdk or codex-cli");
+  }
+
+  return {
+    name,
+    prompt,
+    driver,
+    model: typeof input.model === "string" ? input.model.trim() || undefined : undefined,
+    cwd: typeof input.cwd === "string" ? input.cwd.trim() || undefined : undefined,
+  };
+}

package/node_modules/@pi-claude-code-agent/intercom-bridge/dist/bridge.d.ts

@@ -0,0 +1,48 @@
+import { type RuntimeEvent, type RuntimeStatus } from "@pi-claude-code-agent/runtime";
+import type { AskResult, AttachPeerInput, BridgeOptions, BridgePeer, BridgeState, BridgeTransport, BridgeTransportIncomingMessage, BridgeTransportStatus, IntercomInboundMessage, InterruptPeerResult, LaunchPeerInput } from "./types.js";
+declare const BRIDGE_SYSTEM_PROMPT: string;
+export declare class ClaudeRuntimeIntercomBridge {
+    private readonly runtime;
+    private readonly storageDir;
+    private transport?;
+    private readonly pollIntervalMs;
+    private readonly askTimeoutMs;
+    private readonly peers;
+    constructor(options?: BridgeOptions);
+    launchPeer(input: LaunchPeerInput): Promise<BridgePeer>;
+    attachPeer(input: AttachPeerInput): Promise<BridgePeer>;
+    listPeers(): Promise<BridgePeer[]>;
+    status(name: string): Promise<BridgePeer | undefined>;
+    send(name: string, message: Omit<IntercomInboundMessage, "kind">, options?: {
+        waitForIdle?: boolean;
+    }): Promise<BridgePeer>;
+    ask(name: string, message: Omit<IntercomInboundMessage, "kind">): Promise<AskResult>;
+    reply(name: string, message: Omit<IntercomInboundMessage, "kind">): Promise<BridgePeer>;
+    interrupt(name: string): Promise<BridgePeer>;
+    interruptWithResult(name: string): Promise<InterruptPeerResult>;
+    stop(name: string): Promise<BridgePeer>;
+    disconnect(name: string): Promise<BridgePeer>;
+    setTransport(transport?: BridgeTransport): Promise<void>;
+    restorePeers(): Promise<BridgePeer[]>;
+    transportStatus(): Promise<BridgeTransportStatus | undefined>;
+    hasTransport(): boolean;
+    close(): Promise<void>;
+    private deliver;
+    private waitForTerminalStateOrCurrent;
+    private waitForTerminalState;
+    private syncPeerFromRuntime;
+    private peerFromStatus;
+    private registerTransportPeer;
+    private unregisterTransportPeer;
+    private handleTransportMessage;
+    private rememberPeer;
+    private forgetPeer;
+    private requirePeer;
+    private assertPeerNameAvailable;
+}
+declare function formatInboundMessage(message: IntercomInboundMessage): string;
+declare function extractReplyText(events: RuntimeEvent[]): string;
+declare function extractLatestReplyText(events: RuntimeEvent[]): string;
+declare function mapRuntimeState(state: RuntimeStatus["state"], registered: boolean): BridgeState;
+declare function formatTransportInboundText(message: BridgeTransportIncomingMessage): string;
+export { BRIDGE_SYSTEM_PROMPT, extractLatestReplyText, extractReplyText, formatInboundMessage, formatTransportInboundText, mapRuntimeState };