@getpaseo/server 0.1.62 → 0.1.65

package/dist/server/client/daemon-client.js

@@ -1,8 +1,10 @@
+import { CLIENT_CAPS } from "../shared/client-capabilities.js";
 import { AgentCreateFailedStatusPayloadSchema, AgentCreatedStatusPayloadSchema, AgentRefreshedStatusPayloadSchema, AgentResumedStatusPayloadSchema, parseServerInfoStatusPayload, RestartRequestedStatusPayloadSchema, ShutdownRequestedStatusPayloadSchema, SessionInboundMessageSchema, WSOutboundMessageSchema, } from "../shared/messages.js";
 import { isRelayClientWebSocketUrl } from "../shared/daemon-endpoints.js";
-import { asUint8Array, decodeTerminalSnapshotPayload, decodeTerminalStreamFrame, encodeTerminalResizePayload, encodeTerminalStreamFrame, TerminalStreamOpcode, } from "../shared/terminal-stream-protocol.js";
-import { createRelayE2eeTransportFactory, createWebSocketTransportFactory, decodeMessageData, defaultWebSocketFactory, describeTransportClose, describeTransportError, encodeUtf8String, } from "./daemon-client-transport.js";
+import { asUint8Array, decodeFileTransferFrame, decodeTerminalStreamFrame, FileTransferOpcode, TerminalStreamOpcode, } from "../shared/binary-frames/index.js";
+import { createRelayE2eeTransportFactory, createWebSocketTransportFactory, decodeMessageData, defaultWebSocketFactory, describeTransportClose, describeTransportError, } from "./daemon-client-transport.js";
 import { DaemonClientRuntimeMetrics } from "./daemon-client-runtime-metrics.js";
+import { TerminalStreamRouter } from "./terminal-stream-router.js";
 const consoleLogger = {
     debug: () => { },
     info: (obj, msg) => console.log(msg, obj),
@@ -12,6 +14,12 @@ const consoleLogger = {
 const perfNow = typeof performance !== "undefined" && typeof performance.now === "function"
     ? () => performance.now()
     : () => Date.now();
+function normalizePassword(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    return value.length > 0 ? value : null;
+}
 class DaemonRpcError extends Error {
     constructor(params) {
         const parts = [params.error];
@@ -44,6 +52,52 @@ function normalizeClientId(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
+function decodeBase64ToBytes(base64) {
+    const binary = globalThis.atob(base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        bytes[index] = binary.charCodeAt(index);
+    }
+    return bytes;
+}
+function legacyExplorerFileToBytes(file) {
+    let bytes;
+    if (file.encoding === "base64" && file.content) {
+        bytes = decodeBase64ToBytes(file.content);
+    }
+    else if (file.encoding === "utf-8" && file.content) {
+        bytes = new TextEncoder().encode(file.content);
+    }
+    else {
+        bytes = new Uint8Array();
+    }
+    return {
+        bytes,
+        mime: file.mimeType ?? "application/octet-stream",
+        size: file.size,
+        path: file.path,
+        kind: file.kind,
+        modifiedAt: file.modifiedAt,
+    };
+}
+function binaryFileKind(mime, encoding) {
+    if (mime.startsWith("image/")) {
+        return "image";
+    }
+    if (encoding === "utf-8" || mime.startsWith("text/") || mime === "application/json") {
+        return "text";
+    }
+    return "binary";
+}
+function concatByteChunks(chunks, size) {
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return bytes;
+}
 function hashForLog(value) {
     let hash = 0;
     for (let index = 0; index < value.length; index += 1) {
@@ -96,9 +150,10 @@ export class DaemonClient {
         this.connectionState = { status: "idle" };
         this.checkoutDiffSubscriptions = new Map();
         this.terminalDirectorySubscriptions = new Set();
-        this.terminalSlots = new Map();
-        this.slotTerminals = new Map();
-        this.terminalStreamListeners = new Set();
+        this.terminalStreams = new TerminalStreamRouter();
+        this.pendingBinaryFileReads = new Map();
+        this.activeBinaryFileTransfers = new Map();
+        this.completedBinaryFileReads = new Map();
         this.pendingSendQueue = [];
         this.lastServerInfoMessage = null;
         this.runtimeMetricsInterval = null;
@@ -176,9 +231,14 @@ export class DaemonClient {
             return;
         }
         const headers = {};
-        if (this.config.authHeader) {
-            headers["Authorization"] = this.config.authHeader;
+        const password = normalizePassword(this.config.password);
+        if (password) {
+            headers.Authorization = `Bearer ${password}`;
         }
+        else if (this.config.authHeader) {
+            headers.Authorization = this.config.authHeader;
+        }
+        const protocols = password ? [`paseo.bearer.${password}`] : undefined;
         try {
             // Reconnect can overlap with browser close/error delivery ordering.
             // Always dispose previous transport before constructing the next one.
@@ -199,7 +259,11 @@ export class DaemonClient {
                 });
             }
             const transportUrl = this.resolveTransportUrlForAttempt();
-            const transport = transportFactory({ url: transportUrl, headers });
+            const transport = transportFactory({
+                url: transportUrl,
+                headers,
+                ...(protocols ? { protocols } : {}),
+            });
             this.transport = transport;
             this.lastServerInfoMessage = null;
             this.updateConnectionState({
@@ -328,7 +392,7 @@ export class DaemonClient {
         this.disposeTransport(1000, "Client closed");
         this.clearWaiters(new Error("Daemon client closed"));
         this.rejectPendingSendQueue(new Error("Daemon client closed"));
-        this.clearTerminalSlots();
+        this.terminalStreams.clearSlots();
         this.lastServerInfoMessage = null;
         if (this.runtimeMetricsInterval) {
             clearInterval(this.runtimeMetricsInterval);
@@ -1017,6 +1081,41 @@ export class DaemonClient {
         });
         return status.agent;
     }
+    async importAgent(input) {
+        const requestId = this.createRequestId();
+        const message = SessionInboundMessageSchema.parse({
+            type: "import_agent_request",
+            requestId,
+            provider: input.provider,
+            sessionId: input.sessionId,
+            ...(input.cwd ? { cwd: input.cwd } : {}),
+            ...(input.labels && Object.keys(input.labels).length > 0 ? { labels: input.labels } : {}),
+        });
+        const status = await this.sendRequest({
+            requestId,
+            message,
+            timeout: 15000,
+            options: { skipQueue: true },
+            select: (msg) => {
+                if (msg.type !== "status") {
+                    return null;
+                }
+                const resumed = AgentResumedStatusPayloadSchema.safeParse(msg.payload);
+                if (resumed.success && resumed.data.requestId === requestId) {
+                    return resumed.data;
+                }
+                const failed = AgentCreateFailedStatusPayloadSchema.safeParse(msg.payload);
+                if (failed.success && failed.data.requestId === requestId) {
+                    return failed.data;
+                }
+                return null;
+            },
+        });
+        if (status.status === "agent_create_failed") {
+            throw new Error(status.error);
+        }
+        return status.agent;
+    }
     async refreshAgent(agentId, requestId) {
         const resolvedRequestId = this.createRequestId(requestId);
         const message = SessionInboundMessageSchema.parse({
@@ -1797,7 +1896,7 @@ export class DaemonClient {
                 branchName: input.branchName,
             },
             responseType: "paseo_worktree_archive_response",
-            timeout: 20000,
+            timeout: 60000,
         });
     }
     async createPaseoWorktree(input, requestId) {
@@ -1807,8 +1906,8 @@ export class DaemonClient {
                 type: "create_paseo_worktree_request",
                 cwd: input.cwd,
                 worktreeSlug: input.worktreeSlug,
-                ...(input.attachments && input.attachments.length > 0
-                    ? { attachments: input.attachments }
+                ...(input.firstAgentContext !== undefined
+                    ? { firstAgentContext: input.firstAgentContext }
                     : {}),
                 ...(input.refName !== undefined ? { refName: input.refName } : {}),
                 ...(input.action !== undefined ? { action: input.action } : {}),
@@ -1875,7 +1974,7 @@ export class DaemonClient {
     // ============================================================================
     // File Explorer
     // ============================================================================
-    async exploreFileSystem(cwd, path, mode = "list", requestId) {
+    async requestFileExplorer(cwd, path, mode, requestId, acceptBinary = false) {
         return this.sendCorrelatedSessionRequest({
             requestId,
             message: {
@@ -1883,11 +1982,45 @@ export class DaemonClient {
                 cwd,
                 path,
                 mode,
+                ...(acceptBinary ? { acceptBinary: true } : {}),
             },
             responseType: "file_explorer_response",
             timeout: 10000,
         });
     }
+    async listDirectory(cwd, path, requestId) {
+        const payload = await this.requestFileExplorer(cwd, path, "list", requestId);
+        if (payload.error) {
+            throw new Error(payload.error);
+        }
+        if (!payload.directory) {
+            throw new Error("Directory listing unavailable.");
+        }
+        return payload.directory;
+    }
+    async readFile(cwd, path, requestId) {
+        const resolvedRequestId = this.createRequestId(requestId);
+        this.pendingBinaryFileReads.set(resolvedRequestId, { cwd, path });
+        try {
+            const payload = await this.requestFileExplorer(cwd, path, "file", resolvedRequestId, true);
+            if (payload.error) {
+                throw new Error(payload.error);
+            }
+            const binaryResult = this.completedBinaryFileReads.get(resolvedRequestId);
+            if (binaryResult) {
+                this.completedBinaryFileReads.delete(resolvedRequestId);
+                return binaryResult;
+            }
+            if (!payload.file) {
+                throw new Error("File unavailable.");
+            }
+            return legacyExplorerFileToBytes(payload.file);
+        }
+        finally {
+            this.pendingBinaryFileReads.delete(resolvedRequestId);
+            this.activeBinaryFileTransfers.delete(resolvedRequestId);
+        }
+    }
     async requestDownloadToken(cwd, path, requestId) {
         return this.sendCorrelatedSessionRequest({
             requestId,
@@ -1992,6 +2125,30 @@ export class DaemonClient {
             timeout: 10000,
         });
     }
+    async readProjectConfig(repoRoot, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "read_project_config_request",
+                repoRoot,
+            },
+            responseType: "read_project_config_response",
+            timeout: 10000,
+        });
+    }
+    async writeProjectConfig(input) {
+        return this.sendCorrelatedSessionRequest({
+            requestId: input.requestId,
+            message: {
+                type: "write_project_config_request",
+                repoRoot: input.repoRoot,
+                config: input.config,
+                expectedRevision: input.expectedRevision,
+            },
+            responseType: "write_project_config_response",
+            timeout: 10000,
+        });
+    }
     async refreshProvidersSnapshot(options) {
         return this.sendCorrelatedSessionRequest({
             requestId: options?.requestId,
@@ -2248,39 +2405,22 @@ export class DaemonClient {
             options: { skipQueue: true },
         });
         if (payload.error === null) {
-            this.setTerminalSlot(terminalId, payload.slot);
+            this.terminalStreams.setSlot(terminalId, payload.slot);
         }
         return payload;
     }
     unsubscribeTerminal(terminalId) {
-        this.removeTerminalSlot(terminalId);
+        this.terminalStreams.removeTerminal(terminalId);
         this.sendSessionMessage({
             type: "unsubscribe_terminal_request",
             terminalId,
         });
     }
     sendTerminalInput(terminalId, message) {
-        const slot = this.terminalSlots.get(terminalId);
-        if (typeof slot === "number") {
-            if (message.type === "input") {
-                this.sendBinaryFrame(encodeTerminalStreamFrame({
-                    opcode: TerminalStreamOpcode.Input,
-                    slot,
-                    payload: encodeUtf8String(message.data),
-                }));
-                return;
-            }
-            if (message.type === "resize") {
-                this.sendBinaryFrame(encodeTerminalStreamFrame({
-                    opcode: TerminalStreamOpcode.Resize,
-                    slot,
-                    payload: encodeTerminalResizePayload({
-                        rows: message.rows,
-                        cols: message.cols,
-                    }),
-                }));
-                return;
-            }
+        const frame = this.terminalStreams.encodeInput(terminalId, message);
+        if (frame) {
+            this.sendBinaryFrame(frame);
+            return;
         }
         this.sendSessionMessage({
             type: "terminal_input",
@@ -2510,6 +2650,10 @@ export class DaemonClient {
                 type: "loop/run",
                 prompt: options.prompt,
                 cwd: options.cwd,
+                ...(options.provider ? { provider: options.provider } : {}),
+                ...(options.model ? { model: options.model } : {}),
+                ...(options.verifierProvider ? { verifierProvider: options.verifierProvider } : {}),
+                ...(options.verifierModel ? { verifierModel: options.verifierModel } : {}),
                 ...(options.verifyPrompt ? { verifyPrompt: options.verifyPrompt } : {}),
                 ...(options.verifyChecks && options.verifyChecks.length > 0
                     ? { verifyChecks: options.verifyChecks }
@@ -2573,10 +2717,7 @@ export class DaemonClient {
         });
     }
     onTerminalStreamEvent(handler) {
-        this.terminalStreamListeners.add(handler);
-        return () => {
-            this.terminalStreamListeners.delete(handler);
-        };
+        return this.terminalStreams.onEvent(handler);
     }
     async waitForTerminalStreamEvent(predicate, timeout = 5000) {
         return new Promise((resolve, reject) => {
@@ -2600,32 +2741,6 @@ export class DaemonClient {
     createRequestId(requestId) {
         return requestId ?? crypto.randomUUID();
     }
-    setTerminalSlot(terminalId, slot) {
-        const existingTerminalId = this.slotTerminals.get(slot);
-        if (existingTerminalId && existingTerminalId !== terminalId) {
-            this.terminalSlots.delete(existingTerminalId);
-        }
-        const existingSlot = this.terminalSlots.get(terminalId);
-        if (typeof existingSlot === "number" && existingSlot !== slot) {
-            this.slotTerminals.delete(existingSlot);
-        }
-        this.terminalSlots.set(terminalId, slot);
-        this.slotTerminals.set(slot, terminalId);
-    }
-    removeTerminalSlot(terminalId) {
-        const slot = this.terminalSlots.get(terminalId);
-        if (typeof slot !== "number") {
-            return;
-        }
-        this.terminalSlots.delete(terminalId);
-        if (this.slotTerminals.get(slot) === terminalId) {
-            this.slotTerminals.delete(slot);
-        }
-    }
-    clearTerminalSlots() {
-        this.terminalSlots.clear();
-        this.slotTerminals.clear();
-    }
     getLastServerInfoMessage() {
         return this.lastServerInfoMessage;
     }
@@ -2647,6 +2762,9 @@ export class DaemonClient {
                 clientId: this.config.clientId,
                 clientType: this.config.clientType ?? "cli",
                 protocolVersion: 1,
+                capabilities: {
+                    [CLIENT_CAPS.reasoningMergeEnum]: true,
+                },
                 ...(this.config.appVersion ? { appVersion: this.config.appVersion } : {}),
             }));
         }
@@ -2704,6 +2822,7 @@ export class DaemonClient {
                 .arrayBuffer()
                 .then((buffer) => {
                 this.handleTransportMessage(buffer);
+                return;
             })
                 .catch(() => {
                 // Ignore failed blob decoding and allow reconnect logic to recover.
@@ -2711,24 +2830,17 @@ export class DaemonClient {
             return;
         }
         const rawBytes = asUint8Array(rawData);
-        if (rawBytes) {
-            const frame = decodeTerminalStreamFrame(rawBytes);
-            if (frame) {
-                const binaryStartMs = perfNow();
-                this.handleBinaryFrame(frame);
-                this.runtimeMetrics?.recordBinaryFrame(frame.opcode === TerminalStreamOpcode.Output
-                    ? "output"
-                    : frame.opcode === TerminalStreamOpcode.Snapshot
-                        ? "snapshot"
-                        : "other", rawBytes.byteLength, perfNow() - binaryStartMs);
-                return;
-            }
+        if (rawBytes && this.tryHandleBinaryFrame(rawBytes)) {
+            return;
         }
         const payload = decodeMessageData(rawData);
         if (!payload) {
             return;
         }
-        const bytes = rawBytes?.byteLength ?? payload.length;
+        this.handleJsonPayload(payload, rawBytes?.byteLength);
+    }
+    handleJsonPayload(payload, rawBytesLength) {
+        const bytes = rawBytesLength ?? payload.length;
         const startMs = perfNow();
         let parsedJson;
         try {
@@ -2754,40 +2866,75 @@ export class DaemonClient {
             this.runtimeMetrics?.recordAgentStream(parsed.data.message.payload);
         }
     }
-    handleBinaryFrame(frame) {
-        const terminalId = this.slotTerminals.get(frame.slot);
-        if (!terminalId) {
-            return;
+    tryHandleBinaryFrame(rawBytes) {
+        const fileFrame = decodeFileTransferFrame(rawBytes);
+        if (fileFrame) {
+            this.handleFileTransferFrame(fileFrame);
+            this.runtimeMetrics?.recordBinaryFrame("other", rawBytes.byteLength, 0);
+            return true;
         }
+        const frame = decodeTerminalStreamFrame(rawBytes);
+        if (!frame) {
+            return false;
+        }
+        const binaryStartMs = perfNow();
+        this.terminalStreams.handleFrame(frame);
+        let frameKind = "other";
         if (frame.opcode === TerminalStreamOpcode.Output) {
-            this.emitTerminalStreamEvent({
-                terminalId,
-                type: "output",
-                data: frame.payload,
-            });
-            return;
+            frameKind = "output";
+        }
+        else if (frame.opcode === TerminalStreamOpcode.Snapshot) {
+            frameKind = "snapshot";
         }
-        if (frame.opcode === TerminalStreamOpcode.Snapshot) {
-            const state = decodeTerminalSnapshotPayload(frame.payload);
-            if (!state) {
+        this.runtimeMetrics?.recordBinaryFrame(frameKind, rawBytes.byteLength, perfNow() - binaryStartMs);
+        return true;
+    }
+    handleFileTransferFrame(frame) {
+        if (frame.opcode === FileTransferOpcode.FileBegin) {
+            const pending = this.pendingBinaryFileReads.get(frame.requestId);
+            if (!pending) {
                 return;
             }
-            this.emitTerminalStreamEvent({
-                terminalId,
-                type: "snapshot",
-                state,
+            this.activeBinaryFileTransfers.set(frame.requestId, {
+                ...pending,
+                mime: frame.metadata.mime,
+                size: frame.metadata.size,
+                encoding: frame.metadata.encoding,
+                modifiedAt: frame.metadata.modifiedAt,
+                chunks: [],
             });
+            return;
         }
-    }
-    emitTerminalStreamEvent(event) {
-        for (const listener of this.terminalStreamListeners) {
-            try {
-                listener(event);
-            }
-            catch {
-                // no-op
-            }
+        const transfer = this.activeBinaryFileTransfers.get(frame.requestId);
+        if (!transfer) {
+            return;
+        }
+        if (frame.opcode === FileTransferOpcode.FileChunk) {
+            transfer.chunks.push(frame.payload);
+            return;
         }
+        const bytes = concatByteChunks(transfer.chunks, transfer.size);
+        this.activeBinaryFileTransfers.delete(frame.requestId);
+        this.completedBinaryFileReads.set(frame.requestId, {
+            bytes,
+            mime: transfer.mime,
+            size: transfer.size,
+            path: transfer.path,
+            kind: binaryFileKind(transfer.mime, transfer.encoding),
+            modifiedAt: transfer.modifiedAt,
+        });
+        this.handleSessionMessage({
+            type: "file_explorer_response",
+            payload: {
+                cwd: transfer.cwd,
+                path: transfer.path,
+                mode: "file",
+                directory: null,
+                file: null,
+                error: null,
+                requestId: frame.requestId,
+            },
+        });
     }
     updateConnectionState(next, metadata) {
         const previous = this.connectionState;
@@ -2832,12 +2979,20 @@ export class DaemonClient {
         // and responses from the previous connection will never arrive.
         this.clearWaiters(new Error(reason ?? "Connection lost"));
         this.rejectPendingSendQueue(new Error(reason ?? "Connection lost"));
-        this.clearTerminalSlots();
+        this.terminalStreams.clearSlots();
         this.lastServerInfoMessage = null;
         if (wasDisposed) {
             this.rejectConnect(new Error(reason ?? "Daemon client is disposed"));
             return;
         }
+        this.emitDisconnectedStateForReconnect(reason, input);
+        if (!this.shouldReconnect || this.config.reconnect?.enabled === false) {
+            this.rejectConnect(new Error(reason ?? "Transport disconnected before connect"));
+            return;
+        }
+        this.armReconnectTimer();
+    }
+    emitDisconnectedStateForReconnect(reason, input) {
         this.updateConnectionState({
             status: "disconnected",
             ...(reason ? { reason } : {}),
@@ -2846,10 +3001,8 @@ export class DaemonClient {
             ...(reason ? { reason } : {}),
             ...(input?.reasonCode ? { reasonCode: input.reasonCode } : {}),
         });
-        if (!this.shouldReconnect || this.config.reconnect?.enabled === false) {
-            this.rejectConnect(new Error(reason ?? "Transport disconnected before connect"));
-            return;
-        }
+    }
+    armReconnectTimer() {
         const attempt = this.reconnectAttempt;
         const baseDelay = this.config.reconnect?.baseDelayMs ?? DEFAULT_RECONNECT_BASE_DELAY_MS;
         const maxDelay = this.config.reconnect?.maxDelayMs ?? DEFAULT_RECONNECT_MAX_DELAY_MS;
@@ -2880,7 +3033,7 @@ export class DaemonClient {
             }
         }
         if (msg.type === "terminal_stream_exit") {
-            this.removeTerminalSlot(msg.payload.terminalId);
+            this.terminalStreams.removeTerminal(msg.payload.terminalId);
         }
         if (this.rawMessageListeners.size > 0) {
             for (const handler of this.rawMessageListeners) {