@bytetrue/byspace 0.1.0

package/node_modules/@bytetrue/byspace-protocol/dist/terminal-key-input.d.ts

@@ -0,0 +1,13 @@
+import type { TerminalInputModeState } from "./terminal-input-mode.js";
+export interface TerminalKeyInput {
+    key: string;
+    ctrl?: boolean;
+    alt?: boolean;
+    shift?: boolean;
+    meta?: boolean;
+}
+export interface TerminalKeyInputEncodingOptions {
+    inputMode?: TerminalInputModeState;
+}
+export declare function encodeTerminalKeyInput(input: TerminalKeyInput, options?: TerminalKeyInputEncodingOptions): string;
+//# sourceMappingURL=terminal-key-input.d.ts.map

package/node_modules/@bytetrue/byspace-protocol/dist/terminal-key-input.js

@@ -0,0 +1,201 @@
+const WIN32_LEFT_ALT_PRESSED = 0x0002;
+const WIN32_LEFT_CTRL_PRESSED = 0x0008;
+const WIN32_SHIFT_PRESSED = 0x0010;
+function modifierParam(input) {
+    let value = 1;
+    if (input.shift)
+        value += 1;
+    if (input.alt)
+        value += 2;
+    if (input.ctrl)
+        value += 4;
+    if (input.meta)
+        value += 8;
+    return value;
+}
+function win32ControlKeyState(input) {
+    let value = 0;
+    if (input.shift)
+        value += WIN32_SHIFT_PRESSED;
+    if (input.ctrl)
+        value += WIN32_LEFT_CTRL_PRESSED;
+    if (input.alt)
+        value += WIN32_LEFT_ALT_PRESSED;
+    return value;
+}
+function shouldUseWin32InputMode(input, options) {
+    if (!options.inputMode?.win32InputMode) {
+        return false;
+    }
+    return Boolean(input.shift || input.ctrl || input.alt);
+}
+function shouldUseKittyKeyboardMode(input, options) {
+    if ((options.inputMode?.kittyKeyboardFlags ?? 0) <= 0) {
+        return false;
+    }
+    return Boolean(input.shift || input.ctrl || input.alt || input.meta);
+}
+function encodeWin32EnterKeyInput(input) {
+    const controlKeyState = win32ControlKeyState(input);
+    // ConPTY Win32 input mode: CSI Vk;Sc;Uc;Kd;Cs;Rc _
+    return `\x1b[13;28;13;1;${controlKeyState};1_`;
+}
+function applyAltLikePrefix(sequence, input) {
+    return input.alt ? `\x1b${sequence}` : sequence;
+}
+function ctrlSymbolCode(char) {
+    switch (char) {
+        case " ":
+        case "@":
+        case "2":
+            return "\x00";
+        case "[":
+        case "3":
+            return "\x1b";
+        case "\\":
+        case "4":
+            return "\x1c";
+        case "]":
+        case "5":
+            return "\x1d";
+        case "^":
+        case "6":
+            return "\x1e";
+        case "_":
+        case "/":
+        case "7":
+            return "\x1f";
+        case "8":
+        case "?":
+            return "\x7f";
+        default:
+            return null;
+    }
+}
+function encodeCtrlChar(char, input) {
+    const upper = char.toUpperCase();
+    if (upper.length === 1 && upper >= "A" && upper <= "Z") {
+        return applyAltLikePrefix(String.fromCharCode(upper.charCodeAt(0) - 64), input);
+    }
+    const symbol = ctrlSymbolCode(char);
+    if (symbol !== null) {
+        return applyAltLikePrefix(symbol, input);
+    }
+    if (char.length === 1) {
+        const code = char.charCodeAt(0) & 0x1f;
+        return applyAltLikePrefix(String.fromCharCode(code), input);
+    }
+    return applyAltLikePrefix(char, input);
+}
+function encodePrintableKey(input) {
+    const raw = input.key;
+    const char = input.shift ? raw.toUpperCase() : raw;
+    if (input.ctrl) {
+        return encodeCtrlChar(char, input);
+    }
+    return applyAltLikePrefix(char, input);
+}
+function csiWithModifier(finalByte, input) {
+    const mod = modifierParam(input);
+    return mod === 1 ? `\x1b[${finalByte}` : `\x1b[1;${mod}${finalByte}`;
+}
+function csiTilde(base, input) {
+    const mod = modifierParam(input);
+    return mod === 1 ? `\x1b[${base}~` : `\x1b[${base};${mod}~`;
+}
+function encodeFunctionKey(key, input) {
+    switch (key) {
+        case "F1":
+            return modifierParam(input) === 1 ? "\x1bOP" : csiWithModifier("P", input);
+        case "F2":
+            return modifierParam(input) === 1 ? "\x1bOQ" : csiWithModifier("Q", input);
+        case "F3":
+            return modifierParam(input) === 1 ? "\x1bOR" : csiWithModifier("R", input);
+        case "F4":
+            return modifierParam(input) === 1 ? "\x1bOS" : csiWithModifier("S", input);
+        case "F5":
+            return csiTilde(15, input);
+        case "F6":
+            return csiTilde(17, input);
+        case "F7":
+            return csiTilde(18, input);
+        case "F8":
+            return csiTilde(19, input);
+        case "F9":
+            return csiTilde(20, input);
+        case "F10":
+            return csiTilde(21, input);
+        case "F11":
+            return csiTilde(23, input);
+        case "F12":
+            return csiTilde(24, input);
+        default:
+            return null;
+    }
+}
+function encodeNavigationKey(key, input) {
+    switch (key) {
+        case "ArrowUp":
+            return csiWithModifier("A", input);
+        case "ArrowDown":
+            return csiWithModifier("B", input);
+        case "ArrowRight":
+            return csiWithModifier("C", input);
+        case "ArrowLeft":
+            return csiWithModifier("D", input);
+        case "Home":
+            return csiWithModifier("H", input);
+        case "End":
+            return csiWithModifier("F", input);
+        case "Insert":
+            return csiTilde(2, input);
+        case "Delete":
+            return csiTilde(3, input);
+        case "PageUp":
+            return csiTilde(5, input);
+        case "PageDown":
+            return csiTilde(6, input);
+        default:
+            return null;
+    }
+}
+export function encodeTerminalKeyInput(input, options = {}) {
+    const key = input.key;
+    if (!key) {
+        return "";
+    }
+    if (key.length === 1) {
+        return encodePrintableKey(input);
+    }
+    switch (key) {
+        case "Enter": {
+            const mod = modifierParam(input);
+            if (mod > 1 && shouldUseWin32InputMode(input, options)) {
+                return encodeWin32EnterKeyInput(input);
+            }
+            if (mod > 1 && shouldUseKittyKeyboardMode(input, options)) {
+                return `\x1b[13;${mod}u`;
+            }
+            return "\r";
+        }
+        case "Tab":
+            if (input.shift && !input.ctrl && !input.alt && !input.meta) {
+                return "\x1b[Z";
+            }
+            return applyAltLikePrefix("\t", input);
+        case "Backspace":
+            return applyAltLikePrefix("\x7f", input);
+        case "Escape":
+            return "\x1b";
+        default:
+            break;
+    }
+    const nav = encodeNavigationKey(key, input);
+    if (nav !== null)
+        return nav;
+    const fn = encodeFunctionKey(key, input);
+    if (fn !== null)
+        return fn;
+    return "";
+}
+//# sourceMappingURL=terminal-key-input.js.map

package/node_modules/@bytetrue/byspace-protocol/dist/terminal-profiles.d.ts

@@ -0,0 +1,6 @@
+import type { TerminalProfile } from "./messages.js";
+export declare const DEFAULT_TERMINAL_PROFILES: readonly TerminalProfile[];
+export declare function guessTerminalProfileIcon(command: string): string | undefined;
+export declare function getTerminalProfileIcon(profile: TerminalProfile): string | undefined;
+export declare function resolveTerminalProfiles(terminalProfiles: TerminalProfile[] | undefined): readonly TerminalProfile[];
+//# sourceMappingURL=terminal-profiles.d.ts.map

package/node_modules/@bytetrue/byspace-protocol/dist/terminal-profiles.js

@@ -0,0 +1,28 @@
+import { KNOWN_PROVIDER_ICON_NAMES } from "./provider-icon-names.js";
+export const DEFAULT_TERMINAL_PROFILES = [
+    { id: "claude", name: "Claude Code", command: "claude", icon: "claude" },
+    { id: "codex", name: "Codex", command: "codex", icon: "codex" },
+    { id: "opencode", name: "OpenCode", command: "opencode", icon: "opencode" },
+];
+const WELL_KNOWN_COMMAND_ICONS = new Map(KNOWN_PROVIDER_ICON_NAMES.map((name) => [name, name]));
+function getCommandBaseName(command) {
+    const lastSlash = command.lastIndexOf("/");
+    const lastBackslash = command.lastIndexOf("\\");
+    const start = Math.max(lastSlash, lastBackslash) + 1;
+    const base = command.slice(start).toLowerCase();
+    const dotIndex = base.indexOf(".");
+    return dotIndex > 0 ? base.slice(0, dotIndex) : base;
+}
+export function guessTerminalProfileIcon(command) {
+    return WELL_KNOWN_COMMAND_ICONS.get(getCommandBaseName(command));
+}
+export function getTerminalProfileIcon(profile) {
+    return profile.icon ?? guessTerminalProfileIcon(profile.command);
+}
+export function resolveTerminalProfiles(terminalProfiles) {
+    if (terminalProfiles === undefined) {
+        return DEFAULT_TERMINAL_PROFILES;
+    }
+    return terminalProfiles;
+}
+//# sourceMappingURL=terminal-profiles.js.map

package/node_modules/@bytetrue/byspace-protocol/dist/terminal-snapshot.d.ts

@@ -0,0 +1,3 @@
+import type { TerminalState } from "./messages.js";
+export declare function renderTerminalSnapshotToAnsi(state: TerminalState): string;
+//# sourceMappingURL=terminal-snapshot.d.ts.map

package/node_modules/@bytetrue/byspace-protocol/dist/terminal-snapshot.js

@@ -0,0 +1,178 @@
+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: " " };
+        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/node_modules/@bytetrue/byspace-protocol/dist/terminal-stream-protocol.d.ts

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

package/node_modules/@bytetrue/byspace-protocol/dist/terminal-stream-protocol.js

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

package/node_modules/@bytetrue/byspace-protocol/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/node_modules/@bytetrue/byspace-protocol/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/node_modules/@bytetrue/byspace-protocol/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/node_modules/@bytetrue/byspace-protocol/dist/tool-call-display.js

@@ -0,0 +1,135 @@
+import { getBySpaceToolLeafName, isBySpaceToolName } 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 (isBySpaceToolName(trimmed)) {
+        const leaf = getBySpaceToolLeafName(trimmed);
+        if (leaf) {
+            return humanizeToolName(leaf);
+        }
+    }
+    if (/[:./]/.test(trimmed) || trimmed.includes("__")) {
+        return trimmed;
+    }
+    return trimmed
+        .replace(/[._-]+/g, " ")
+        .split(" ")
+        .filter((segment) => segment.length > 0)
+        .map((segment) => `${segment[0]?.toUpperCase() ?? ""}${segment.slice(1)}`)
+        .join(" ");
+}
+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/node_modules/@bytetrue/byspace-protocol/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 isBySpaceToolName(name: string): boolean;
+export declare function getBySpaceToolLeafName(name: string): string | null;
+export declare function isLikelyExternalToolName(name: string): boolean;
+//# sourceMappingURL=tool-name-normalization.d.ts.map