@camerontaylor/paseo-protocol 0.8.0-fork.1

package/dist/terminal-snapshot.js

@@ -0,0 +1,184 @@
+const DEFAULT_STYLE = {
+    fg: undefined,
+    bg: undefined,
+    fgMode: undefined,
+    bgMode: undefined,
+    bold: false,
+    italic: false,
+    underline: false,
+    dim: false,
+    inverse: false,
+    strikethrough: false,
+};
+export function renderTerminalSnapshotToAnsi(state) {
+    const rows = [...state.scrollback, ...state.grid];
+    const wrapFlags = [...(state.scrollbackWrapped ?? []), ...(state.gridWrapped ?? [])];
+    // Soft-wrapped lines can only be re-wrapped on resize when we know which rows
+    // were continuations. With that per-row flag we replay each logical line as one
+    // unbroken run (autowrap on) so xterm marks the continuations wrapped and reflows
+    // them. Without it (old daemon) we keep the verbatim per-row replay: autowrap off
+    // plus a hard newline per row.
+    const hasWrapInfo = wrapFlags.length === rows.length;
+    const lines = hasWrapInfo ? [] : ["\u001b[?7l"];
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+        const row = rows[rowIndex] ?? [];
+        const continuesToNextRow = hasWrapInfo && wrapFlags[rowIndex] === true;
+        // A continuation row must fill the full width so the next row first cell
+        // triggers xterm auto-wrap, which is what marks the row wrapped/reflowable.
+        lines.push(renderTerminalRow(row, continuesToNextRow ? state.cols : undefined));
+        if (rowIndex < rows.length - 1 && !continuesToNextRow) {
+            lines.push("\r\n");
+        }
+    }
+    lines.push("\u001b[0m");
+    const cursorPresentationAnsi = renderCursorPresentationToAnsi(state.cursor);
+    if (cursorPresentationAnsi) {
+        lines.push(cursorPresentationAnsi);
+    }
+    lines.push(`\u001b[${state.cursor.row + 1};${state.cursor.col + 1}H`);
+    lines.push(state.cursor.hidden ? "\u001b[?25l" : "\u001b[?25h");
+    if (!hasWrapInfo) {
+        lines.push("\u001b[?7h");
+    }
+    return lines.join("");
+}
+function renderCursorPresentationToAnsi(cursor) {
+    if (!cursor.style) {
+        return null;
+    }
+    const cursorStyleCode = (() => {
+        if (cursor.style === "block") {
+            return cursor.blink === false ? 2 : 1;
+        }
+        if (cursor.style === "underline") {
+            return cursor.blink === false ? 4 : 3;
+        }
+        return cursor.blink === false ? 6 : 5;
+    })();
+    return `\u001b[${cursorStyleCode} q`;
+}
+function renderTerminalRow(row, padToCols) {
+    const output = [];
+    const contentLength = getTerminalRowLength(row);
+    const length = padToCols !== undefined ? Math.max(contentLength, padToCols) : contentLength;
+    let previousStyle = DEFAULT_STYLE;
+    for (let index = 0; index < length; index += 1) {
+        const cell = row[index] ?? { char: " " };
+        // An empty char marks a wide-char continuation cell. The glyph in the
+        // previous cell already advances the cursor two columns, so emitting
+        // anything here would shift the rest of the row one column right.
+        if (cell.char === "") {
+            continue;
+        }
+        const nextStyle = getTerminalStyle(cell);
+        if (!terminalStylesEqual(previousStyle, nextStyle)) {
+            output.push(styleToAnsi(nextStyle));
+            previousStyle = nextStyle;
+        }
+        output.push(cell.char || " ");
+    }
+    if (!terminalStylesEqual(previousStyle, DEFAULT_STYLE)) {
+        output.push("\u001b[0m");
+    }
+    return output.join("");
+}
+function getTerminalRowLength(row) {
+    for (let index = row.length - 1; index >= 0; index -= 1) {
+        const cell = row[index];
+        if (!cell) {
+            continue;
+        }
+        if (cell.char !== " ") {
+            return index + 1;
+        }
+        if (cell.fg !== undefined ||
+            cell.bg !== undefined ||
+            cell.fgMode !== undefined ||
+            cell.bgMode !== undefined ||
+            cell.bold ||
+            cell.italic ||
+            cell.underline ||
+            cell.dim ||
+            cell.inverse ||
+            cell.strikethrough) {
+            return index + 1;
+        }
+    }
+    return 0;
+}
+function getTerminalStyle(cell) {
+    return {
+        fg: cell.fg,
+        bg: cell.bg,
+        fgMode: cell.fgMode,
+        bgMode: cell.bgMode,
+        bold: Boolean(cell.bold),
+        italic: Boolean(cell.italic),
+        underline: Boolean(cell.underline),
+        dim: Boolean(cell.dim),
+        inverse: Boolean(cell.inverse),
+        strikethrough: Boolean(cell.strikethrough),
+    };
+}
+function terminalStylesEqual(left, right) {
+    return (left.fg === right.fg &&
+        left.bg === right.bg &&
+        left.fgMode === right.fgMode &&
+        left.bgMode === right.bgMode &&
+        left.bold === right.bold &&
+        left.italic === right.italic &&
+        left.underline === right.underline &&
+        left.dim === right.dim &&
+        left.inverse === right.inverse &&
+        left.strikethrough === right.strikethrough);
+}
+function styleToAnsi(style) {
+    const codes = ["0"];
+    if (style.bold) {
+        codes.push("1");
+    }
+    if (style.dim) {
+        codes.push("2");
+    }
+    if (style.italic) {
+        codes.push("3");
+    }
+    if (style.underline) {
+        codes.push("4");
+    }
+    if (style.inverse) {
+        codes.push("7");
+    }
+    if (style.strikethrough) {
+        codes.push("9");
+    }
+    if (style.fg !== undefined && style.fgMode !== undefined) {
+        codes.push(...colorToSgr(style.fgMode, style.fg, false));
+    }
+    if (style.bg !== undefined && style.bgMode !== undefined) {
+        codes.push(...colorToSgr(style.bgMode, style.bg, true));
+    }
+    return `\u001b[${codes.join(";")}m`;
+}
+function colorToSgr(mode, value, background) {
+    if (mode === 1) {
+        if (value >= 8) {
+            return [String((background ? 100 : 90) + (value - 8))];
+        }
+        return [String((background ? 40 : 30) + value)];
+    }
+    if (mode === 2) {
+        return [background ? "48" : "38", "5", String(value)];
+    }
+    if (mode === 3) {
+        return [
+            background ? "48" : "38",
+            "2",
+            String((value >> 16) & 0xff),
+            String((value >> 8) & 0xff),
+            String(value & 0xff),
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=terminal-snapshot.js.map

package/dist/terminal-stream-protocol.d.ts

@@ -0,0 +1,2 @@
+export * from "./binary-frames/terminal.js";
+//# sourceMappingURL=terminal-stream-protocol.d.ts.map

package/dist/terminal-stream-protocol.js

@@ -0,0 +1,2 @@
+export * from "./binary-frames/terminal.js";
+//# sourceMappingURL=terminal-stream-protocol.js.map

package/dist/terminal-subscription-key.d.ts

@@ -0,0 +1,2 @@
+export declare function terminalSubscriptionKey(cwd: string, workspaceId: string | undefined): string;
+//# sourceMappingURL=terminal-subscription-key.d.ts.map

package/dist/terminal-subscription-key.js

@@ -0,0 +1,9 @@
+// A terminal directory subscription is scoped to a (cwd, workspaceId) pair, not
+// cwd alone: under Model B two workspaces can share a cwd, and each must track
+// and tear down its own live subscription without disturbing the other. An
+// absent workspaceId (old clients) keys to the cwd on its own. The `::`
+// separator cannot collide with a workspace id, which is always `wks_<hex>`.
+export function terminalSubscriptionKey(cwd, workspaceId) {
+    return workspaceId === undefined ? cwd : `${workspaceId}::${cwd}`;
+}
+//# sourceMappingURL=terminal-subscription-key.js.map

package/dist/timeline-identity.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTimelineItem } from "./agent-types.js";
+export declare function timelineItemIdentity(item: AgentTimelineItem): string | null;
+//# sourceMappingURL=timeline-identity.d.ts.map

package/dist/timeline-identity.js

@@ -0,0 +1,8 @@
+export function timelineItemIdentity(item) {
+    if (item.type === "tool_call")
+        return item.callId;
+    if (item.type === "plugin")
+        return `${item.pluginId}/${item.id}`;
+    return null;
+}
+//# sourceMappingURL=timeline-identity.js.map

package/dist/tool-call-display.d.ts

@@ -0,0 +1,11 @@
+import type { ToolCallTimelineItem } from "./agent-types.js";
+export type ToolCallDisplayInput = Pick<ToolCallTimelineItem, "name" | "status" | "error" | "metadata" | "detail"> & {
+    cwd?: string;
+};
+export interface ToolCallDisplayModel {
+    displayName: string;
+    summary?: string;
+    errorText?: string;
+}
+export declare function buildToolCallDisplayModel(input: ToolCallDisplayInput): ToolCallDisplayModel;
+//# sourceMappingURL=tool-call-display.d.ts.map

package/dist/tool-call-display.js

@@ -0,0 +1,136 @@
+import { getPaseoToolLeafName, isPaseoToolName } from "./tool-name-normalization.js";
+import { stripCwdPrefix } from "./path-utils.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function humanizeToolName(name) {
+    const trimmed = name.trim();
+    if (!trimmed) {
+        return name;
+    }
+    if (isPaseoToolName(trimmed)) {
+        const leaf = getPaseoToolLeafName(trimmed);
+        if (leaf) {
+            return humanizeToolName(leaf);
+        }
+    }
+    if (/[:./]/.test(trimmed) || trimmed.includes("__")) {
+        return trimmed;
+    }
+    return trimmed
+        .replace(/[._-]+/g, " ")
+        .split(" ")
+        .filter((segment) => segment.length > 0)
+        .join(" ")
+        .toLowerCase()
+        .replace(/^./, (character) => character.toUpperCase());
+}
+function formatErrorText(error) {
+    if (error === null || error === undefined) {
+        return undefined;
+    }
+    if (typeof error === "string") {
+        return error;
+    }
+    if (isRecord(error) && typeof error.content === "string") {
+        return error.content;
+    }
+    try {
+        return JSON.stringify(error, null, 2);
+    }
+    catch {
+        return String(error);
+    }
+}
+function buildFilePathDisplay(displayName, filePath, cwd) {
+    return {
+        displayName,
+        summary: stripCwdPrefix(filePath, cwd),
+    };
+}
+function buildCanonicalDetailDisplay(input) {
+    switch (input.detail.type) {
+        case "shell":
+            return {
+                displayName: "Shell",
+                summary: input.detail.command,
+            };
+        case "read":
+            return buildFilePathDisplay("Read", input.detail.filePath, input.cwd);
+        case "edit":
+            return buildFilePathDisplay("Edit", input.detail.filePath, input.cwd);
+        case "write":
+            return buildFilePathDisplay("Write", input.detail.filePath, input.cwd);
+        case "search":
+            return {
+                displayName: "Search",
+                summary: input.detail.query,
+            };
+        case "fetch":
+            return {
+                displayName: "Fetch",
+                summary: input.detail.url,
+            };
+        case "worktree_setup":
+            return {
+                displayName: "Worktree setup",
+                summary: input.detail.branchName,
+            };
+        case "sub_agent":
+            return {
+                displayName: readString(input.detail.subAgentType) ?? "Task",
+                summary: readString(input.detail.description),
+            };
+        case "plain_text":
+            return {
+                summary: input.detail.label,
+            };
+        case "plan":
+            return {
+                displayName: "Plan",
+            };
+        case "unknown":
+            return {};
+        default:
+            throw new Error("unreachable");
+    }
+}
+function buildUnknownDetailOverride(input) {
+    const lowerName = input.name.trim().toLowerCase();
+    if (input.detail.type === "unknown" && lowerName === "task") {
+        return {
+            displayName: "Task",
+            summary: isRecord(input.metadata) ? readString(input.metadata.subAgentActivity) : undefined,
+        };
+    }
+    if (input.detail.type === "unknown" && lowerName === "thinking") {
+        return {
+            displayName: "Thinking",
+        };
+    }
+    if (lowerName === "terminal") {
+        return {
+            displayName: "Terminal",
+            summary: input.detail.type === "plain_text" ? readString(input.detail.label) : undefined,
+        };
+    }
+    return {};
+}
+export function buildToolCallDisplayModel(input) {
+    const canonicalDisplay = buildCanonicalDetailDisplay(input);
+    const unknownDetailOverride = buildUnknownDetailOverride(input);
+    const displayName = unknownDetailOverride.displayName ??
+        canonicalDisplay.displayName ??
+        humanizeToolName(input.name);
+    const summary = unknownDetailOverride.summary ?? canonicalDisplay.summary;
+    const errorText = input.status === "failed" ? formatErrorText(input.error) : undefined;
+    return {
+        displayName,
+        ...(summary ? { summary } : {}),
+        ...(errorText ? { errorText } : {}),
+    };
+}
+//# sourceMappingURL=tool-call-display.js.map

package/dist/tool-name-normalization.d.ts

@@ -0,0 +1,9 @@
+export declare function normalizeToolName(name: string): string;
+export declare function tokenizeToolName(name: string): string[];
+export declare function getToolLeafName(name: string): string | null;
+export declare function isSpeakToolName(name: string): boolean;
+export declare function isLikelyNamespacedToolName(name: string): boolean;
+export declare function isPaseoToolName(name: string): boolean;
+export declare function getPaseoToolLeafName(name: string): string | null;
+export declare function isLikelyExternalToolName(name: string): boolean;
+//# sourceMappingURL=tool-name-normalization.d.ts.map

package/dist/tool-name-normalization.js

@@ -0,0 +1,82 @@
+const TOOL_TOKEN_REGEX = /[a-z0-9]+/g;
+const STANDARD_NAMESPACE_SEPARATOR_REGEX = /[.:/]/;
+export function normalizeToolName(name) {
+    return name.trim().toLowerCase();
+}
+export function tokenizeToolName(name) {
+    const normalized = normalizeToolName(name);
+    return normalized.match(TOOL_TOKEN_REGEX) ?? [];
+}
+export function getToolLeafName(name) {
+    const tokens = tokenizeToolName(name);
+    return tokens.length > 0 ? tokens[tokens.length - 1] : null;
+}
+export function isSpeakToolName(name) {
+    return getToolLeafName(name) === "speak";
+}
+export function isLikelyNamespacedToolName(name) {
+    const normalized = normalizeToolName(name);
+    if (STANDARD_NAMESPACE_SEPARATOR_REGEX.test(normalized)) {
+        return true;
+    }
+    if (!normalized.includes("__")) {
+        return false;
+    }
+    // Keep `__` handling strict to avoid false positives on arbitrary custom names.
+    const segments = normalized.split("__").filter((segment) => segment.length > 0);
+    if (segments.length >= 3) {
+        return true;
+    }
+    if (segments.length === 2 && segments[1].includes("_")) {
+        return true;
+    }
+    return false;
+}
+export function isPaseoToolName(name) {
+    const normalized = normalizeToolName(name);
+    if (isSpeakToolName(normalized)) {
+        return false;
+    }
+    if (normalized.includes("__")) {
+        const segments = normalized.split("__").filter((s) => s.length > 0);
+        return (segments.length >= 3 &&
+            segments[0] === "mcp" &&
+            (segments[1] === "paseo" || segments[1].startsWith("paseo_")));
+    }
+    if (normalized.includes(".")) {
+        const firstSegment = normalized.split(".")[0];
+        return firstSegment === "paseo" || firstSegment.startsWith("paseo_");
+    }
+    return false;
+}
+export function getPaseoToolLeafName(name) {
+    const normalized = normalizeToolName(name);
+    if (normalized.includes("__")) {
+        const segments = normalized.split("__").filter((s) => s.length > 0);
+        if (segments.length >= 3 &&
+            segments[0] === "mcp" &&
+            (segments[1] === "paseo" || segments[1].startsWith("paseo_"))) {
+            return segments.slice(2).join("__");
+        }
+        return null;
+    }
+    if (normalized.includes(".")) {
+        const firstSegment = normalized.split(".")[0];
+        if (firstSegment === "paseo" || firstSegment.startsWith("paseo_")) {
+            return normalized.split(".").slice(1).join(".");
+        }
+        return null;
+    }
+    return null;
+}
+export function isLikelyExternalToolName(name) {
+    const normalized = normalizeToolName(name);
+    if (!normalized) {
+        return false;
+    }
+    if (isSpeakToolName(normalized)) {
+        return true;
+    }
+    return isLikelyNamespacedToolName(normalized);
+}
+//# sourceMappingURL=tool-name-normalization.js.map