@getpaseo/protocol 0.1.84

package/dist/schedule/types.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { AgentProviderSchema } from "@getpaseo/protocol/provider-manifest";
+export const ScheduleStatusSchema = z.enum(["active", "paused", "completed"]);
+export const ScheduleCadenceSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("every"),
+        everyMs: z.number().int().positive(),
+    }),
+    z.object({
+        type: z.literal("cron"),
+        expression: z.string().trim().min(1),
+    }),
+]);
+export const ScheduleTargetSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("agent"),
+        agentId: z.string().uuid(),
+    }),
+    z.object({
+        type: z.literal("new-agent"),
+        config: z.object({
+            provider: AgentProviderSchema,
+            cwd: z.string().trim().min(1),
+            modeId: z.string().trim().min(1).optional(),
+            model: z.string().trim().min(1).optional(),
+            thinkingOptionId: z.string().trim().min(1).optional(),
+            title: z.string().trim().min(1).nullable().optional(),
+            approvalPolicy: z.string().trim().min(1).optional(),
+            sandboxMode: z.string().trim().min(1).optional(),
+            networkAccess: z.boolean().optional(),
+            webSearch: z.boolean().optional(),
+            featureValues: z.record(z.unknown()).optional(),
+            extra: z
+                .object({
+                codex: z.record(z.unknown()).optional(),
+                claude: z.record(z.unknown()).optional(),
+            })
+                .partial()
+                .optional(),
+            systemPrompt: z.string().optional(),
+            mcpServers: z.record(z.unknown()).optional(),
+        }),
+    }),
+]);
+export const ScheduleRunSchema = z.object({
+    id: z.string(),
+    scheduledFor: z.string(),
+    startedAt: z.string(),
+    endedAt: z.string().nullable(),
+    status: z.enum(["running", "succeeded", "failed"]),
+    agentId: z.string().uuid().nullable(),
+    output: z.string().nullable(),
+    error: z.string().nullable(),
+});
+export const StoredScheduleSchema = z.object({
+    id: z.string(),
+    name: z.string().nullable(),
+    prompt: z.string().min(1),
+    cadence: ScheduleCadenceSchema,
+    target: ScheduleTargetSchema,
+    status: ScheduleStatusSchema,
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    nextRunAt: z.string().nullable(),
+    lastRunAt: z.string().nullable(),
+    pausedAt: z.string().nullable(),
+    expiresAt: z.string().nullable(),
+    maxRuns: z.number().int().positive().nullable(),
+    runs: z.array(ScheduleRunSchema),
+});
+export const ScheduleSummarySchema = StoredScheduleSchema.omit({
+    runs: true,
+});
+//# sourceMappingURL=types.js.map

package/dist/terminal-input-mode.d.ts

@@ -0,0 +1,26 @@
+export interface TerminalInputModeFeedResult {
+    changed: boolean;
+    responses: string[];
+}
+export interface TerminalInputModeState {
+    kittyKeyboardFlags: number;
+    win32InputMode: boolean;
+}
+export declare const DEFAULT_TERMINAL_INPUT_MODE_STATE: TerminalInputModeState;
+export declare function terminalInputModeSupportsModifiedEnter(state: TerminalInputModeState): boolean;
+export declare function terminalInputModeStatesEqual(left: TerminalInputModeState, right: TerminalInputModeState): boolean;
+export declare class TerminalInputModeTracker {
+    private kittyKeyboardFlags;
+    private win32InputMode;
+    private readonly kittyKeyboardStack;
+    private pending;
+    feed(data: string): TerminalInputModeFeedResult;
+    reset(): void;
+    getState(): TerminalInputModeState;
+    getKittyKeyboardFlags(): number;
+    supportsModifiedEnter(): boolean;
+    getPreamble(): string;
+    private applyKittyKeyboardSequence;
+    private applyPrivateModeSequence;
+}
+//# sourceMappingURL=terminal-input-mode.d.ts.map

package/dist/terminal-input-mode.js

@@ -0,0 +1,151 @@
+export const DEFAULT_TERMINAL_INPUT_MODE_STATE = {
+    kittyKeyboardFlags: 0,
+    win32InputMode: false,
+};
+const ESC = String.fromCharCode(0x1b);
+const WIN32_INPUT_MODE = 9001;
+const CSI_INPUT_MODE_SEQUENCE = new RegExp(`${ESC}\\[(?:([<>=?]?)([0-9;]*)u|\\?([0-9;]*)([hl]))`, "g");
+const INCOMPLETE_CSI_INPUT_MODE_SEQUENCE = new RegExp(`${ESC}\\[[<>=?]?[0-9;]*$`);
+function parseFirstParam(params) {
+    const first = params.split(";")[0];
+    if (!first || !/^\d+$/.test(first)) {
+        return null;
+    }
+    return Number(first);
+}
+function parseSecondParam(params) {
+    const second = params.split(";")[1];
+    if (!second || !/^\d+$/.test(second)) {
+        return null;
+    }
+    return Number(second);
+}
+function parsePrivateModeParams(params) {
+    const modes = new Set();
+    for (const param of params.split(";")) {
+        if (/^\d+$/.test(param)) {
+            modes.add(Number(param));
+        }
+    }
+    return modes;
+}
+export function terminalInputModeSupportsModifiedEnter(state) {
+    return state.kittyKeyboardFlags > 0 || state.win32InputMode;
+}
+export function terminalInputModeStatesEqual(left, right) {
+    return (left.kittyKeyboardFlags === right.kittyKeyboardFlags &&
+        left.win32InputMode === right.win32InputMode);
+}
+export class TerminalInputModeTracker {
+    constructor() {
+        this.kittyKeyboardFlags = 0;
+        this.win32InputMode = false;
+        this.kittyKeyboardStack = [];
+        this.pending = "";
+    }
+    feed(data) {
+        if (data.length === 0) {
+            return { changed: false, responses: [] };
+        }
+        const text = `${this.pending}${data}`;
+        this.pending = "";
+        let changed = false;
+        const responses = [];
+        let consumedUntil = 0;
+        CSI_INPUT_MODE_SEQUENCE.lastIndex = 0;
+        for (;;) {
+            const match = CSI_INPUT_MODE_SEQUENCE.exec(text);
+            if (!match) {
+                break;
+            }
+            consumedUntil = CSI_INPUT_MODE_SEQUENCE.lastIndex;
+            if (match[4]) {
+                changed = this.applyPrivateModeSequence(match[3] ?? "", match[4]) || changed;
+                continue;
+            }
+            const result = this.applyKittyKeyboardSequence(match[1] ?? "", match[2] ?? "");
+            changed = changed || result.changed;
+            responses.push(...result.responses);
+        }
+        const tail = text.slice(consumedUntil);
+        const pendingStart = tail.lastIndexOf(`${ESC}[`);
+        if (pendingStart >= 0) {
+            const pending = tail.slice(pendingStart);
+            if (INCOMPLETE_CSI_INPUT_MODE_SEQUENCE.test(pending)) {
+                this.pending = pending;
+            }
+        }
+        return { changed, responses };
+    }
+    reset() {
+        this.kittyKeyboardFlags = 0;
+        this.win32InputMode = false;
+        this.kittyKeyboardStack.length = 0;
+        this.pending = "";
+    }
+    getState() {
+        return {
+            kittyKeyboardFlags: this.kittyKeyboardFlags,
+            win32InputMode: this.win32InputMode,
+        };
+    }
+    getKittyKeyboardFlags() {
+        return this.kittyKeyboardFlags;
+    }
+    supportsModifiedEnter() {
+        return terminalInputModeSupportsModifiedEnter(this.getState());
+    }
+    getPreamble() {
+        const parts = [];
+        if (this.kittyKeyboardFlags > 0) {
+            parts.push(`\x1b[=${this.kittyKeyboardFlags};1u`);
+        }
+        if (this.win32InputMode) {
+            parts.push("\x1b[?9001h");
+        }
+        return parts.join("");
+    }
+    applyKittyKeyboardSequence(prefix, params) {
+        const previousFlags = this.kittyKeyboardFlags;
+        switch (prefix) {
+            case ">": {
+                this.kittyKeyboardStack.push(this.kittyKeyboardFlags);
+                this.kittyKeyboardFlags = parseFirstParam(params) ?? 1;
+                break;
+            }
+            case "=": {
+                const mode = parseSecondParam(params) ?? 1;
+                this.kittyKeyboardFlags = mode === 0 ? 0 : (parseFirstParam(params) ?? 0);
+                break;
+            }
+            case "<": {
+                const count = Math.max(1, parseFirstParam(params) ?? 1);
+                for (let index = 0; index < count; index += 1) {
+                    this.kittyKeyboardFlags = this.kittyKeyboardStack.pop() ?? 0;
+                }
+                break;
+            }
+            case "?":
+                return {
+                    changed: false,
+                    responses: [`\x1b[?${this.kittyKeyboardFlags}u`],
+                };
+            default:
+                return { changed: false, responses: [] };
+        }
+        return {
+            changed: this.kittyKeyboardFlags !== previousFlags,
+            responses: [],
+        };
+    }
+    applyPrivateModeSequence(params, final) {
+        const modes = parsePrivateModeParams(params);
+        if (!modes.has(WIN32_INPUT_MODE)) {
+            return false;
+        }
+        const previous = this.win32InputMode;
+        this.win32InputMode = final === "h";
+        return this.win32InputMode !== previous;
+    }
+}
+//# sourceMappingURL=terminal-input-mode.js.map

package/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/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/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/dist/terminal-snapshot.js

@@ -0,0 +1,165 @@
+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 lines = ["\u001b[?7l"];
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+        const row = rows[rowIndex] ?? [];
+        lines.push(renderTerminalRow(row));
+        if (rowIndex < rows.length - 1) {
+            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");
+    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) {
+    const output = [];
+    const length = getTerminalRowLength(row);
+    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/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/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