@getpaseo/server 0.1.58 → 0.1.60

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

@@ -2,12 +2,16 @@ import { AgentCreateFailedStatusPayloadSchema, AgentCreatedStatusPayloadSchema,
 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 { DaemonClientRuntimeMetrics } from "./daemon-client-runtime-metrics.js";
 const consoleLogger = {
     debug: () => { },
-    info: (obj, msg) => console.info(msg, obj),
+    info: (obj, msg) => console.log(msg, obj),
     warn: (obj, msg) => console.warn(msg, obj),
     error: (obj, msg) => console.error(msg, obj),
 };
+const perfNow = typeof performance !== "undefined" && typeof performance.now === "function"
+    ? () => performance.now()
+    : () => Date.now();
 class DaemonRpcError extends Error {
     constructor(params) {
         const parts = [params.error];
@@ -97,6 +101,8 @@ export class DaemonClient {
         this.terminalStreamListeners = new Set();
         this.pendingSendQueue = [];
         this.lastServerInfoMessage = null;
+        this.runtimeMetricsInterval = null;
+        this.runtimeMetrics = null;
         this.logger = config.logger ?? consoleLogger;
         this.logConnectionPath = isRelayClientWebSocketUrl(this.config.url) ? "relay" : "direct";
         let parsedUrlForLog = null;
@@ -119,6 +125,22 @@ export class DaemonClient {
                 Number.isFinite(this.config.runtimeGeneration)
                 ? this.config.runtimeGeneration
                 : null;
+        const runtimeMetricsIntervalMs = typeof config.runtimeMetricsIntervalMs === "number" && config.runtimeMetricsIntervalMs > 0
+            ? config.runtimeMetricsIntervalMs
+            : 0;
+        if (runtimeMetricsIntervalMs > 0) {
+            const runtimeMetricsWindowMs = typeof config.runtimeMetricsWindowMs === "number" && config.runtimeMetricsWindowMs > 0
+                ? Math.max(config.runtimeMetricsWindowMs, runtimeMetricsIntervalMs)
+                : undefined;
+            this.runtimeMetrics = new DaemonClientRuntimeMetrics(this.logger, {
+                connectionPath: this.logConnectionPath,
+                serverId: this.logServerId,
+                getConnectionStatus: () => this.connectionState.status,
+            }, runtimeMetricsWindowMs ? { windowMs: runtimeMetricsWindowMs } : undefined);
+            this.runtimeMetricsInterval = setInterval(() => {
+                this.runtimeMetrics?.flush();
+            }, runtimeMetricsIntervalMs);
+        }
     }
     // ============================================================================
     // Connection
@@ -308,6 +330,12 @@ export class DaemonClient {
         this.rejectPendingSendQueue(new Error("Daemon client closed"));
         this.clearTerminalSlots();
         this.lastServerInfoMessage = null;
+        if (this.runtimeMetricsInterval) {
+            clearInterval(this.runtimeMetricsInterval);
+            this.runtimeMetricsInterval = null;
+            this.runtimeMetrics?.flush({ final: true });
+            this.runtimeMetrics = null;
+        }
         this.updateConnectionState({ status: "disposed" }, { event: "DISPOSE", reason: "Client closed", reasonCode: "disposed" });
     }
     ensureConnected() {
@@ -641,6 +669,7 @@ export class DaemonClient {
         const message = SessionInboundMessageSchema.parse({
             type: "fetch_agents_request",
             requestId: resolvedRequestId,
+            ...(options?.scope ? { scope: options.scope } : {}),
             ...(options?.filter ? { filter: options.filter } : {}),
             ...(options?.sort ? { sort: options.sort } : {}),
             ...(options?.page ? { page: options.page } : {}),
@@ -662,6 +691,31 @@ export class DaemonClient {
             },
         });
     }
+    async fetchAgentHistory(options) {
+        const resolvedRequestId = this.createRequestId(options?.requestId);
+        const message = SessionInboundMessageSchema.parse({
+            type: "fetch_agent_history_request",
+            requestId: resolvedRequestId,
+            ...(options?.filter ? { filter: options.filter } : {}),
+            ...(options?.sort ? { sort: options.sort } : {}),
+            ...(options?.page ? { page: options.page } : {}),
+        });
+        return this.sendRequest({
+            requestId: resolvedRequestId,
+            message,
+            timeout: 10000,
+            options: { skipQueue: true },
+            select: (msg) => {
+                if (msg.type !== "fetch_agent_history_response") {
+                    return null;
+                }
+                if (msg.payload.requestId !== resolvedRequestId) {
+                    return null;
+                }
+                return msg.payload;
+            },
+        });
+    }
     async fetchWorkspaces(options) {
         const resolvedRequestId = this.createRequestId(options?.requestId);
         const message = SessionInboundMessageSchema.parse({
@@ -699,6 +753,18 @@ export class DaemonClient {
             timeout: 10000,
         });
     }
+    async startWorkspaceScript(workspaceId, scriptName, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "start_workspace_script_request",
+                workspaceId,
+                scriptName,
+            },
+            responseType: "start_workspace_script_response",
+            timeout: 10000,
+        });
+    }
     async listAvailableEditors(requestId) {
         return this.sendCorrelatedSessionRequest({
             requestId,
@@ -732,6 +798,17 @@ export class DaemonClient {
             timeout: 10000,
         });
     }
+    async fetchWorkspaceSetupStatus(workspaceId, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "workspace_setup_status_request",
+                workspaceId,
+            },
+            responseType: "workspace_setup_status_response",
+            timeout: 10000,
+        });
+    }
     async fetchAgent(agentId, requestId) {
         const resolvedRequestId = this.createRequestId(requestId);
         const message = SessionInboundMessageSchema.parse({
@@ -798,10 +875,14 @@ export class DaemonClient {
             type: "create_agent_request",
             requestId,
             config,
+            ...(options.workspaceId !== undefined ? { workspaceId: options.workspaceId } : {}),
             ...(options.initialPrompt ? { initialPrompt: options.initialPrompt } : {}),
             ...(options.clientMessageId ? { clientMessageId: options.clientMessageId } : {}),
             ...(options.outputSchema ? { outputSchema: options.outputSchema } : {}),
             ...(options.images && options.images.length > 0 ? { images: options.images } : {}),
+            ...(options.attachments && options.attachments.length > 0
+                ? { attachments: options.attachments }
+                : {}),
             ...(options.git ? { git: options.git } : {}),
             ...(options.worktreeName ? { worktreeName: options.worktreeName } : {}),
             ...(options.labels && Object.keys(options.labels).length > 0
@@ -1004,6 +1085,7 @@ export class DaemonClient {
             text,
             ...(messageId ? { messageId } : {}),
             ...(options?.images ? { images: options.images } : {}),
+            ...(options?.attachments ? { attachments: options.attachments } : {}),
         });
         const payload = await this.sendRequest({
             requestId,
@@ -1458,15 +1540,20 @@ export class DaemonClient {
         return responsePromise;
     }
     normalizeCheckoutDiffCompare(compare) {
-        const ignoreWhitespace = compare.ignoreWhitespace === true;
         if (compare.mode === "uncommitted") {
-            return { mode: "uncommitted", ignoreWhitespace };
+            return compare.ignoreWhitespace === true
+                ? { mode: "uncommitted", ignoreWhitespace: true }
+                : { mode: "uncommitted" };
         }
         const trimmedBaseRef = compare.baseRef?.trim();
         if (!trimmedBaseRef) {
-            return { mode: "base", ignoreWhitespace };
+            return compare.ignoreWhitespace === true
+                ? { mode: "base", ignoreWhitespace: true }
+                : { mode: "base" };
         }
-        return { mode: "base", baseRef: trimmedBaseRef, ignoreWhitespace };
+        return compare.ignoreWhitespace === true
+            ? { mode: "base", baseRef: trimmedBaseRef, ignoreWhitespace: true }
+            : { mode: "base", baseRef: trimmedBaseRef };
     }
     async getCheckoutDiff(cwd, compare, requestId) {
         const oneShotSubscriptionId = `oneshot-checkout-diff:${crypto.randomUUID()}`;
@@ -1626,6 +1713,20 @@ export class DaemonClient {
             timeout: 60000,
         });
     }
+    async pullRequestTimeline(input, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "pull_request_timeline_request",
+                cwd: input.cwd,
+                prNumber: input.prNumber,
+                repoOwner: input.repoOwner,
+                repoName: input.repoName,
+            },
+            responseType: "pull_request_timeline_response",
+            timeout: 60000,
+        });
+    }
     async checkoutSwitchBranch(cwd, branch, requestId) {
         return this.sendCorrelatedSessionRequest({
             requestId,
@@ -1706,6 +1807,12 @@ export class DaemonClient {
                 type: "create_paseo_worktree_request",
                 cwd: input.cwd,
                 worktreeSlug: input.worktreeSlug,
+                ...(input.attachments && input.attachments.length > 0
+                    ? { attachments: input.attachments }
+                    : {}),
+                ...(input.refName !== undefined ? { refName: input.refName } : {}),
+                ...(input.action !== undefined ? { action: input.action } : {}),
+                ...(input.githubPrNumber !== undefined ? { githubPrNumber: input.githubPrNumber } : {}),
             },
             responseType: "create_paseo_worktree_response",
             timeout: 60000,
@@ -1736,6 +1843,20 @@ export class DaemonClient {
             timeout: 10000,
         });
     }
+    async searchGitHub(options, requestId) {
+        return this.sendCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "github_search_request",
+                cwd: options.cwd,
+                query: options.query,
+                limit: options.limit,
+                kinds: options.kinds,
+            },
+            responseType: "github_search_response",
+            timeout: 15000,
+        });
+    }
     async getDirectorySuggestions(options, requestId) {
         return this.sendCorrelatedSessionRequest({
             requestId,
@@ -2010,9 +2131,6 @@ export class DaemonClient {
                 if (settled) {
                     return;
                 }
-                if (message.type !== "agent_update") {
-                    return;
-                }
                 if (message.payload.kind !== "upsert") {
                     return;
                 }
@@ -2096,12 +2214,15 @@ export class DaemonClient {
             options: { skipQueue: true },
         });
     }
-    async createTerminal(cwd, name, requestId) {
+    async createTerminal(cwd, name, requestId, options) {
         const resolvedRequestId = this.createRequestId(requestId);
         const message = SessionInboundMessageSchema.parse({
             type: "create_terminal_request",
             cwd,
             name,
+            agentId: options?.agentId,
+            command: options?.command,
+            args: options?.args,
             requestId: resolvedRequestId,
         });
         return this.sendCorrelatedRequest({
@@ -2593,7 +2714,13 @@ export class DaemonClient {
         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;
             }
         }
@@ -2601,6 +2728,8 @@ export class DaemonClient {
         if (!payload) {
             return;
         }
+        const bytes = rawBytes?.byteLength ?? payload.length;
+        const startMs = perfNow();
         let parsedJson;
         try {
             parsedJson = JSON.parse(payload);
@@ -2615,9 +2744,15 @@ export class DaemonClient {
             return;
         }
         if (parsed.data.type === "pong") {
+            this.runtimeMetrics?.recordMessage("pong", bytes, perfNow() - startMs);
             return;
         }
         this.handleSessionMessage(parsed.data.message);
+        const msgType = parsed.data.message.type;
+        this.runtimeMetrics?.recordMessage(msgType, bytes, perfNow() - startMs);
+        if (parsed.data.message.type === "agent_stream") {
+            this.runtimeMetrics?.recordAgentStream(parsed.data.message.payload);
+        }
     }
     handleBinaryFrame(frame) {
         const terminalId = this.slotTerminals.get(frame.slot);
@@ -2811,6 +2946,12 @@ export class DaemonClient {
                     workspaceId: msg.payload.kind === "upsert" ? msg.payload.workspace.id : msg.payload.id,
                     payload: msg.payload,
                 };
+            case "workspace_setup_progress":
+                return {
+                    type: "workspace_setup_progress",
+                    workspaceId: msg.payload.workspaceId,
+                    payload: msg.payload,
+                };
             case "agent_stream":
                 return {
                     type: "agent_stream",
@@ -2907,7 +3048,7 @@ export class DaemonClient {
     }
 }
 function resolveAgentConfig(options) {
-    const { config, provider, cwd, initialPrompt: _initialPrompt, images: _images, git: _git, worktreeName: _worktreeName, requestId: _requestId, labels: _labels, ...overrides } = options;
+    const { config, provider, cwd, workspaceId: _workspaceId, initialPrompt: _initialPrompt, images: _images, git: _git, worktreeName: _worktreeName, requestId: _requestId, labels: _labels, ...overrides } = options;
     const baseConfig = {
         ...(provider ? { provider } : {}),
         ...(cwd ? { cwd } : {}),