@getpaseo/client 0.1.97-beta.2 → 0.1.97

package/dist/daemon-client.d.ts

@@ -544,7 +544,9 @@ export declare class DaemonClient {
     private lastServerInfoMessage;
     private runtimeMetricsInterval;
     private runtimeMetrics;
-    private livenessProbe;
+    private pingProbe;
+    private livenessHeartbeatTimer;
+    private lastLivenessRttMs;
     private consecutiveLivenessFailures;
     constructor(config: DaemonClientConfig);
     connect(): Promise<void>;
@@ -558,6 +560,7 @@ export declare class DaemonClient {
     get isConnected(): boolean;
     get isConnecting(): boolean;
     get lastError(): string | null;
+    getLastLivenessRttMs(): number | null;
     subscribe(handler: DaemonEventHandler): () => void;
     subscribeRawMessages(handler: (message: SessionOutboundMessage) => void): () => void;
     on<TType extends SessionOutboundMessage["type"]>(type: TType, handler: (message: Extract<SessionOutboundMessage, {
@@ -612,11 +615,14 @@ export declare class DaemonClient {
         serverSentAt: number;
         rttMs: number;
     }>;
-    checkLiveness(params?: {
+    measureLatency(params?: {
         timeoutMs?: number;
-    }): Promise<{
-        rttMs: number;
-    }>;
+    }): Promise<number>;
+    private livenessPing;
+    private sendPingAwaitRtt;
+    private startLivenessHeartbeat;
+    private stopLivenessHeartbeat;
+    private scheduleNextLivenessHeartbeat;
     fetchAgents(options?: FetchAgentsOptions): Promise<FetchAgentsPayload>;
     fetchAgentHistory(options?: FetchAgentHistoryOptions): Promise<FetchAgentHistoryPayload>;
     fetchRecentProviderSessions(options?: FetchRecentProviderSessionsOptions): Promise<FetchRecentProviderSessionsPayload>;
@@ -642,6 +648,9 @@ export declare class DaemonClient {
     renameProject(projectId: string, customName: string | null, requestId?: string): Promise<{
         customName: string | null;
     }>;
+    removeProject(projectId: string, requestId?: string): Promise<{
+        removedWorkspaceIds: string[];
+    }>;
     setWorkspaceTitle(workspaceId: string, title: string | null, requestId?: string): Promise<{
         title: string | null;
     }>;
@@ -904,9 +913,9 @@ export declare class DaemonClient {
     private scheduleReconnect;
     private emitDisconnectedStateForReconnect;
     private armReconnectTimer;
-    private resolveLivenessProbe;
-    private clearLivenessProbe;
-    private rejectLivenessProbe;
+    private resolvePingProbe;
+    private clearPingProbe;
+    private rejectPingProbe;
     private recordLivenessFailure;
     private handleSessionMessage;
     private resolveWaiters;

package/dist/daemon-client.js

@@ -35,10 +35,25 @@ class DaemonRpcError extends Error {
         this.code = params.code;
     }
 }
+class PingTimeoutError extends Error {
+    constructor(timeoutMs) {
+        super(`Ping timed out (${timeoutMs}ms)`);
+        this.timeoutMs = timeoutMs;
+        this.name = "PingTimeoutError";
+    }
+}
+function toTimeoutError(error, label, timeoutMs) {
+    if (error instanceof PingTimeoutError) {
+        return new Error(`${label} timed out (${timeoutMs}ms)`);
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
 const DEFAULT_RECONNECT_BASE_DELAY_MS = 1500;
 const DEFAULT_RECONNECT_MAX_DELAY_MS = 30000;
 const DEFAULT_CONNECT_TIMEOUT_MS = 15000;
 const DEFAULT_LIVENESS_TIMEOUT_MS = 5000;
+const LIVENESS_HEARTBEAT_INTERVAL_MS = 10000;
+const LIVENESS_HEARTBEAT_TIMEOUT_MS = 15000;
 const LIVENESS_FAILURE_RECONNECT_THRESHOLD = 2;
 /** Default timeout for waiting for connection before sending queued messages */
 const DEFAULT_SEND_QUEUE_TIMEOUT_MS = 10000;
@@ -161,7 +176,9 @@ export class DaemonClient {
         this.lastServerInfoMessage = null;
         this.runtimeMetricsInterval = null;
         this.runtimeMetrics = null;
-        this.livenessProbe = null;
+        this.pingProbe = null;
+        this.livenessHeartbeatTimer = null;
+        this.lastLivenessRttMs = null;
         this.consecutiveLivenessFailures = 0;
         this.logger = config.logger ?? consoleLogger;
         this.logConnectionPath = isRelayClientWebSocketUrl(this.config.url) ? "relay" : "direct";
@@ -397,7 +414,7 @@ export class DaemonClient {
         this.disposeTransport(1000, "Client closed");
         this.clearWaiters(new Error("Daemon client closed"));
         this.rejectPendingSendQueue(new Error("Daemon client closed"));
-        this.rejectLivenessProbe(new Error("Daemon client closed"));
+        this.rejectPingProbe(new Error("Daemon client closed"));
         this.terminalStreams.clearSlots();
         this.lastServerInfoMessage = null;
         if (this.runtimeMetricsInterval) {
@@ -440,6 +457,9 @@ export class DaemonClient {
     get lastError() {
         return this.lastErrorValue;
     }
+    getLastLivenessRttMs() {
+        return this.lastLivenessRttMs;
+    }
     // ============================================================================
     // Message Subscription
     // ============================================================================
@@ -765,15 +785,32 @@ export class DaemonClient {
             rttMs: Date.now() - clientSentAt,
         };
     }
-    checkLiveness(params) {
+    measureLatency(params) {
+        const timeoutMs = Math.max(1, params?.timeoutMs ?? DEFAULT_LIVENESS_TIMEOUT_MS);
+        return this.sendPingAwaitRtt({ timeoutMs, drivesLivenessFailure: false }).catch((error) => {
+            throw toTimeoutError(error, "Latency measurement", timeoutMs);
+        });
+    }
+    async livenessPing(params) {
+        const timeoutMs = Math.max(1, params?.timeoutMs ?? DEFAULT_LIVENESS_TIMEOUT_MS);
+        try {
+            const rttMs = await this.sendPingAwaitRtt({ timeoutMs, drivesLivenessFailure: true });
+            this.lastLivenessRttMs = rttMs;
+            return rttMs;
+        }
+        catch (error) {
+            throw toTimeoutError(error, "Liveness check", timeoutMs);
+        }
+    }
+    sendPingAwaitRtt(params) {
         if (this.connectionState.status !== "connected" || !this.transport) {
             return Promise.reject(new Error(`Transport not connected (status: ${this.connectionState.status})`));
         }
-        if (this.livenessProbe) {
-            return this.livenessProbe.promise;
+        if (this.pingProbe) {
+            return this.pingProbe.promise;
         }
         const startedAt = perfNow();
-        const timeoutMs = Math.max(1, params?.timeoutMs ?? DEFAULT_LIVENESS_TIMEOUT_MS);
+        const timeoutMs = params.timeoutMs;
         let resolveProbe = null;
         let rejectProbe = null;
         const promise = new Promise((resolve, reject) => {
@@ -785,28 +822,58 @@ export class DaemonClient {
             resolve: (value) => resolveProbe?.(value),
             reject: (error) => rejectProbe?.(error),
             timeoutHandle: setTimeout(() => {
-                if (this.livenessProbe !== probe) {
+                if (this.pingProbe !== probe) {
                     return;
                 }
-                this.livenessProbe = null;
-                const error = new Error(`Liveness check timed out (${timeoutMs}ms)`);
+                this.pingProbe = null;
+                const error = new PingTimeoutError(timeoutMs);
                 probe.reject(error);
-                this.recordLivenessFailure(error);
+                if (probe.drivesLivenessFailure) {
+                    this.recordLivenessFailure(toTimeoutError(error, "Liveness check", timeoutMs));
+                }
             }, timeoutMs),
             startedAt,
+            drivesLivenessFailure: params.drivesLivenessFailure,
         };
-        this.livenessProbe = probe;
+        this.pingProbe = probe;
         try {
             this.transport.send(JSON.stringify({ type: "ping" }));
         }
         catch (error) {
-            this.clearLivenessProbe();
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.recordLivenessFailure(err);
-            return Promise.reject(err);
+            this.clearPingProbe();
+            const sendError = error instanceof Error ? error : new Error(String(error));
+            if (probe.drivesLivenessFailure) {
+                this.recordLivenessFailure(sendError);
+            }
+            return Promise.reject(sendError);
         }
         return promise;
     }
+    startLivenessHeartbeat() {
+        this.stopLivenessHeartbeat();
+        this.lastLivenessRttMs = null;
+        this.scheduleNextLivenessHeartbeat();
+    }
+    stopLivenessHeartbeat() {
+        if (!this.livenessHeartbeatTimer) {
+            return;
+        }
+        clearTimeout(this.livenessHeartbeatTimer);
+        this.livenessHeartbeatTimer = null;
+    }
+    scheduleNextLivenessHeartbeat() {
+        if (this.connectionState.status !== "connected" || this.livenessHeartbeatTimer) {
+            return;
+        }
+        this.livenessHeartbeatTimer = setTimeout(() => {
+            this.livenessHeartbeatTimer = null;
+            this.livenessPing({ timeoutMs: LIVENESS_HEARTBEAT_TIMEOUT_MS })
+                .catch(() => { })
+                .finally(() => {
+                this.scheduleNextLivenessHeartbeat();
+            });
+        }, LIVENESS_HEARTBEAT_INTERVAL_MS);
+    }
     // ============================================================================
     // Agent RPCs (requestId-correlated)
     // ============================================================================
@@ -1163,6 +1230,20 @@ export class DaemonClient {
         }
         return { customName: payload.customName };
     }
+    async removeProject(projectId, requestId) {
+        const payload = await this.sendNamespacedCorrelatedSessionRequest({
+            requestId,
+            message: {
+                type: "project.remove.request",
+                projectId,
+            },
+            timeout: 10000,
+        });
+        if (!payload.accepted) {
+            throw new Error(payload.error ?? "removeProject rejected");
+        }
+        return { removedWorkspaceIds: payload.removedWorkspaceIds };
+    }
     async setWorkspaceTitle(workspaceId, title, requestId) {
         const payload = await this.sendCorrelatedSessionRequest({
             requestId,
@@ -3134,6 +3215,7 @@ export class DaemonClient {
         }
     }
     disposeTransport(code = 1001, reason = "Reconnecting") {
+        this.stopLivenessHeartbeat();
         this.cleanupTransport();
         if (this.transport) {
             try {
@@ -3217,7 +3299,7 @@ export class DaemonClient {
         }
         this.consecutiveLivenessFailures = 0;
         if (parsed.data.type === "pong") {
-            this.resolveLivenessProbe();
+            this.resolvePingProbe();
             this.runtimeMetrics?.recordMessage("pong", bytes, perfNow() - startMs);
             return;
         }
@@ -3231,6 +3313,7 @@ export class DaemonClient {
     tryHandleBinaryFrame(rawBytes) {
         const fileFrame = decodeFileTransferFrame(rawBytes);
         if (fileFrame) {
+            this.consecutiveLivenessFailures = 0;
             this.handleFileTransferFrame(fileFrame);
             this.runtimeMetrics?.recordBinaryFrame("other", rawBytes.byteLength, 0);
             return true;
@@ -3239,6 +3322,7 @@ export class DaemonClient {
         if (!frame) {
             return false;
         }
+        this.consecutiveLivenessFailures = 0;
         const binaryStartMs = perfNow();
         this.terminalStreams.handleFrame(frame);
         let frameKind = "other";
@@ -3344,7 +3428,7 @@ 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.rejectLivenessProbe(new Error(reason ?? "Connection lost"));
+        this.rejectPingProbe(new Error(reason ?? "Connection lost"));
         this.terminalStreams.clearSlots();
         this.lastServerInfoMessage = null;
         if (wasDisposed) {
@@ -3382,29 +3466,29 @@ export class DaemonClient {
             this.attemptConnect();
         }, delay);
     }
-    resolveLivenessProbe() {
-        const probe = this.livenessProbe;
+    resolvePingProbe() {
+        const probe = this.pingProbe;
         if (!probe) {
             return;
         }
-        this.livenessProbe = null;
+        this.pingProbe = null;
         clearTimeout(probe.timeoutHandle);
-        probe.resolve({ rttMs: perfNow() - probe.startedAt });
+        probe.resolve(perfNow() - probe.startedAt);
     }
-    clearLivenessProbe() {
-        const probe = this.livenessProbe;
+    clearPingProbe() {
+        const probe = this.pingProbe;
         if (!probe) {
             return;
         }
-        this.livenessProbe = null;
+        this.pingProbe = null;
         clearTimeout(probe.timeoutHandle);
     }
-    rejectLivenessProbe(error) {
-        const probe = this.livenessProbe;
+    rejectPingProbe(error) {
+        const probe = this.pingProbe;
         if (!probe) {
             return;
         }
-        this.livenessProbe = null;
+        this.pingProbe = null;
         clearTimeout(probe.timeoutHandle);
         probe.reject(error);
     }
@@ -3431,6 +3515,7 @@ export class DaemonClient {
                     this.resetConnectTimeout();
                     this.reconnectAttempt = 0;
                     this.updateConnectionState({ status: "connected" }, { event: "HELLO_SERVER_INFO" });
+                    this.startLivenessHeartbeat();
                     this.resubscribeCheckoutDiffSubscriptions();
                     this.resubscribeTerminalDirectorySubscriptions();
                     this.flushPendingSendQueue();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/client",
-  "version": "0.1.97-beta.2",
+  "version": "0.1.97",
   "description": "Paseo client SDK package",
   "files": [
     "dist",
@@ -35,9 +35,9 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@getpaseo/protocol": "0.1.97-beta.2",
-    "@getpaseo/relay": "0.1.97-beta.2",
-    "zod": "^3.23.8"
+    "@getpaseo/protocol": "0.1.97",
+    "@getpaseo/relay": "0.1.97",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@types/node": "^20.9.0",