@vibedeckx/linux-x64 0.1.10

package/dist/remote-patch-cache.js

@@ -0,0 +1,190 @@
+/**
+ * In-memory cache for remote agent session WebSocket messages.
+ *
+ * Stores the raw serialized WS messages that flow through the proxy so that
+ * returning to a previously-visited remote workspace can replay history from
+ * local memory instead of re-fetching everything from the remote server.
+ *
+ * Also manages persistent remote WebSocket connections and frontend subscriber
+ * tracking so that remote output is always cached even when no frontend is
+ * connected.
+ */
+export class RemotePatchCache {
+    cache = new Map();
+    getOrCreate(sessionId) {
+        let entry = this.cache.get(sessionId);
+        if (!entry) {
+            entry = {
+                messages: [],
+                patchCount: 0,
+                finished: false,
+                remoteWs: null,
+                subscribers: new Set(),
+                reconnecting: false,
+                reconnectTimer: null,
+                reconnectAttempt: 0,
+            };
+            this.cache.set(sessionId, entry);
+        }
+        return entry;
+    }
+    get(sessionId) {
+        return this.cache.get(sessionId);
+    }
+    hasData(sessionId) {
+        const entry = this.cache.get(sessionId);
+        return !!entry && entry.messages.length > 0;
+    }
+    /**
+     * Append a raw WS message to the cache.
+     * @param raw - The serialized message string
+     * @param isJsonPatch - Whether this message is a JsonPatch (increments patchCount)
+     */
+    appendMessage(sessionId, raw, isJsonPatch) {
+        const entry = this.getOrCreate(sessionId);
+        entry.messages.push(raw);
+        if (isJsonPatch) {
+            entry.patchCount++;
+        }
+    }
+    /** Full cache replacement (used when cache is detected as stale). */
+    replaceAll(sessionId, messages, patchCount) {
+        const existing = this.cache.get(sessionId);
+        // Preserve persistent WS, subscribers, and reconnection state across cache replacement
+        const remoteWs = existing?.remoteWs ?? null;
+        const subscribers = existing?.subscribers ?? new Set();
+        const reconnecting = existing?.reconnecting ?? false;
+        const reconnectTimer = existing?.reconnectTimer ?? null;
+        const reconnectAttempt = existing?.reconnectAttempt ?? 0;
+        this.cache.set(sessionId, {
+            messages,
+            patchCount,
+            finished: false,
+            remoteWs,
+            subscribers,
+            reconnecting,
+            reconnectTimer,
+            reconnectAttempt,
+        });
+    }
+    setFinished(sessionId) {
+        const entry = this.cache.get(sessionId);
+        if (entry) {
+            entry.finished = true;
+        }
+    }
+    /** Store a persistent remote WebSocket connection. */
+    setRemoteWs(sessionId, ws) {
+        const entry = this.getOrCreate(sessionId);
+        entry.remoteWs = ws;
+    }
+    /** Get the persistent remote WS if it exists and is open. */
+    getRemoteWs(sessionId) {
+        const entry = this.cache.get(sessionId);
+        if (!entry?.remoteWs)
+            return null;
+        // WebSocket.OPEN === 1
+        if (entry.remoteWs.readyState !== 1) {
+            entry.remoteWs = null;
+            return null;
+        }
+        return entry.remoteWs;
+    }
+    /** Add a frontend WebSocket as a subscriber. */
+    addSubscriber(sessionId, frontendWs) {
+        const entry = this.getOrCreate(sessionId);
+        entry.subscribers.add(frontendWs);
+    }
+    /** Remove a frontend WebSocket subscriber. */
+    removeSubscriber(sessionId, frontendWs) {
+        const entry = this.cache.get(sessionId);
+        if (entry) {
+            entry.subscribers.delete(frontendWs);
+        }
+    }
+    // ---- Reconnection state management ----
+    setReconnecting(sessionId, value) {
+        const entry = this.getOrCreate(sessionId);
+        entry.reconnecting = value;
+    }
+    isReconnecting(sessionId) {
+        const entry = this.cache.get(sessionId);
+        return !!entry?.reconnecting;
+    }
+    setReconnectTimer(sessionId, timer) {
+        const entry = this.getOrCreate(sessionId);
+        // Clear any existing timer first
+        if (entry.reconnectTimer) {
+            clearTimeout(entry.reconnectTimer);
+        }
+        entry.reconnectTimer = timer;
+    }
+    clearReconnectTimer(sessionId) {
+        const entry = this.cache.get(sessionId);
+        if (entry?.reconnectTimer) {
+            clearTimeout(entry.reconnectTimer);
+            entry.reconnectTimer = null;
+        }
+    }
+    getReconnectAttempt(sessionId) {
+        return this.cache.get(sessionId)?.reconnectAttempt ?? 0;
+    }
+    incrementReconnectAttempt(sessionId) {
+        const entry = this.cache.get(sessionId);
+        if (entry)
+            entry.reconnectAttempt++;
+    }
+    resetReconnectAttempt(sessionId) {
+        const entry = this.cache.get(sessionId);
+        if (entry)
+            entry.reconnectAttempt = 0;
+    }
+    /** Broadcast a raw message to all subscribers, auto-removing dead ones. */
+    broadcast(sessionId, raw) {
+        const entry = this.cache.get(sessionId);
+        if (!entry)
+            return;
+        for (const ws of entry.subscribers) {
+            try {
+                ws.send(raw);
+            }
+            catch {
+                entry.subscribers.delete(ws);
+            }
+        }
+    }
+    /**
+     * Close all remote WebSockets and clear all reconnect timers for graceful shutdown
+     */
+    shutdown() {
+        for (const [id, entry] of this.cache) {
+            if (entry.reconnectTimer) {
+                clearTimeout(entry.reconnectTimer);
+            }
+            if (entry.remoteWs) {
+                try {
+                    entry.remoteWs.close();
+                }
+                catch { /* ignore */ }
+            }
+        }
+        this.cache.clear();
+    }
+    delete(sessionId) {
+        const entry = this.cache.get(sessionId);
+        if (entry) {
+            // Clear reconnect timer first to prevent respawning
+            if (entry.reconnectTimer) {
+                clearTimeout(entry.reconnectTimer);
+            }
+            // Close persistent remote WS if open
+            if (entry.remoteWs) {
+                try {
+                    entry.remoteWs.close();
+                }
+                catch { /* ignore */ }
+            }
+        }
+        this.cache.delete(sessionId);
+    }
+}

package/dist/reverse-connect-client.d.ts

@@ -0,0 +1,27 @@
+import type { FastifyInstance } from "fastify";
+export declare class ReverseConnectClient {
+    private ws;
+    private localServer;
+    private serverUrl;
+    private token;
+    private localPort;
+    private localChannels;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private noPingTimer;
+    private shuttingDown;
+    constructor(localServer: FastifyInstance, serverUrl: string, token: string, localPort: number);
+    connect(): void;
+    shutdown(): void;
+    private handleFrame;
+    private handleHttpRequest;
+    private handleWsOpen;
+    private handleWsData;
+    private handleWsClose;
+    private handlePing;
+    private sendFrame;
+    private scheduleReconnect;
+    private resetNoPingTimer;
+    private clearNoPingTimer;
+    private closeAllLocalChannels;
+}

package/dist/reverse-connect-client.js

@@ -0,0 +1,255 @@
+import WebSocket from "ws";
+const RECONNECT_BASE_DELAY_MS = 1000;
+const RECONNECT_MAX_DELAY_MS = 30_000;
+const NO_PING_TIMEOUT_MS = 60_000;
+export class ReverseConnectClient {
+    ws = null;
+    localServer;
+    serverUrl;
+    token;
+    localPort;
+    localChannels = new Map();
+    reconnectAttempt = 0;
+    reconnectTimer = null;
+    noPingTimer = null;
+    shuttingDown = false;
+    constructor(localServer, serverUrl, token, localPort) {
+        this.localServer = localServer;
+        this.serverUrl = serverUrl;
+        this.token = token;
+        this.localPort = localPort;
+    }
+    connect() {
+        if (this.shuttingDown)
+            return;
+        const cleanUrl = this.serverUrl.replace(/\/+$/, "");
+        const wsProtocol = cleanUrl.startsWith("https") ? "wss" : "ws";
+        const wsUrl = cleanUrl.replace(/^https?/, wsProtocol);
+        const connectUrl = `${wsUrl}/api/reverse-connect?token=${encodeURIComponent(this.token)}`;
+        console.log(`[ReverseClient] Connecting to ${cleanUrl}...`);
+        this.ws = new WebSocket(connectUrl, {
+            maxPayload: 11 * 1024 * 1024,
+        });
+        this.ws.on("open", () => {
+            console.log("[ReverseClient] Connected to server");
+            this.reconnectAttempt = 0;
+            this.resetNoPingTimer();
+            // Send status ready
+            const frame = { type: "status", ready: true };
+            this.ws.send(JSON.stringify(frame));
+        });
+        this.ws.on("message", (data) => {
+            try {
+                const frame = JSON.parse(data.toString());
+                this.handleFrame(frame);
+            }
+            catch (err) {
+                console.error("[ReverseClient] Failed to parse frame:", err);
+            }
+        });
+        this.ws.on("close", (code, reason) => {
+            console.log(`[ReverseClient] Disconnected (code=${code}, reason=${reason?.toString() || ""})`);
+            this.clearNoPingTimer();
+            this.closeAllLocalChannels();
+            this.ws = null;
+            if (!this.shuttingDown) {
+                this.scheduleReconnect();
+            }
+        });
+        this.ws.on("error", (err) => {
+            console.error("[ReverseClient] WebSocket error:", err.message);
+        });
+    }
+    shutdown() {
+        this.shuttingDown = true;
+        this.clearNoPingTimer();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.closeAllLocalChannels();
+        if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+            this.ws.close(1000, "Shutdown");
+        }
+        this.ws = null;
+    }
+    async handleFrame(frame) {
+        switch (frame.type) {
+            case "http_request":
+                await this.handleHttpRequest(frame);
+                break;
+            case "ws_open":
+                this.handleWsOpen(frame);
+                break;
+            case "ws_data":
+                this.handleWsData(frame);
+                break;
+            case "ws_close":
+                this.handleWsClose(frame);
+                break;
+            case "ping":
+                this.handlePing(frame);
+                break;
+            default:
+                break;
+        }
+    }
+    async handleHttpRequest(frame) {
+        try {
+            let status;
+            let responseHeaders = {};
+            let body;
+            if (frame.port) {
+                // Direct fetch to localhost:{port} — used by browser proxy to reach dev servers
+                const url = `http://localhost:${frame.port}${frame.path}`;
+                const fetchInit = {
+                    method: frame.method,
+                    headers: frame.headers,
+                    redirect: "follow",
+                };
+                if (frame.body && frame.method !== "GET" && frame.method !== "HEAD") {
+                    fetchInit.body = frame.body;
+                }
+                const response = await fetch(url, fetchInit);
+                status = response.status;
+                response.headers.forEach((val, key) => {
+                    responseHeaders[key] = val;
+                });
+                body = await response.text();
+            }
+            else {
+                // Route through Fastify server — used for API proxy
+                const response = await this.localServer.inject({
+                    method: frame.method,
+                    url: frame.path,
+                    headers: frame.headers,
+                    payload: frame.body,
+                });
+                status = response.statusCode;
+                for (const [key, val] of Object.entries(response.headers)) {
+                    if (typeof val === "string") {
+                        responseHeaders[key] = val;
+                    }
+                    else if (Array.isArray(val)) {
+                        responseHeaders[key] = val.join(", ");
+                    }
+                }
+                body = response.payload;
+            }
+            const responseFrame = {
+                type: "http_response",
+                requestId: frame.requestId,
+                status,
+                headers: responseHeaders,
+                body,
+            };
+            this.sendFrame(responseFrame);
+        }
+        catch (err) {
+            console.error(`[ReverseClient] request error for ${frame.requestId}:`, err);
+            const errorFrame = {
+                type: "http_response",
+                requestId: frame.requestId,
+                status: 502,
+                headers: {},
+                body: JSON.stringify({ error: err instanceof Error ? err.message : "Request failed" }),
+            };
+            this.sendFrame(errorFrame);
+        }
+    }
+    handleWsOpen(frame) {
+        const wsUrl = `ws://127.0.0.1:${this.localPort}${frame.path}${frame.query ? `?${frame.query}` : ""}`;
+        console.log(`[ReverseClient] Opening local WS channel ${frame.channelId} → ${frame.path}`);
+        const localWs = new WebSocket(wsUrl);
+        localWs.on("open", () => {
+            this.localChannels.set(frame.channelId, localWs);
+        });
+        localWs.on("message", (data) => {
+            const dataFrame = {
+                type: "ws_data",
+                channelId: frame.channelId,
+                data: data.toString(),
+            };
+            this.sendFrame(dataFrame);
+        });
+        localWs.on("close", (code, reason) => {
+            this.localChannels.delete(frame.channelId);
+            const closeFrame = {
+                type: "ws_close",
+                channelId: frame.channelId,
+                code,
+                reason: reason?.toString(),
+            };
+            this.sendFrame(closeFrame);
+        });
+        localWs.on("error", (err) => {
+            console.error(`[ReverseClient] Local WS error for channel ${frame.channelId}:`, err.message);
+            this.localChannels.delete(frame.channelId);
+            const closeFrame = {
+                type: "ws_close",
+                channelId: frame.channelId,
+                code: 1011,
+                reason: "Local WebSocket error",
+            };
+            this.sendFrame(closeFrame);
+        });
+    }
+    handleWsData(frame) {
+        const localWs = this.localChannels.get(frame.channelId);
+        if (localWs && localWs.readyState === WebSocket.OPEN) {
+            localWs.send(frame.data);
+        }
+    }
+    handleWsClose(frame) {
+        const localWs = this.localChannels.get(frame.channelId);
+        if (localWs) {
+            localWs.close(frame.code, frame.reason);
+            this.localChannels.delete(frame.channelId);
+        }
+    }
+    handlePing(frame) {
+        this.resetNoPingTimer();
+        const pong = { type: "pong", ts: frame.ts };
+        this.sendFrame(pong);
+    }
+    sendFrame(frame) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(frame));
+        }
+    }
+    scheduleReconnect() {
+        const delay = Math.min(RECONNECT_BASE_DELAY_MS * Math.pow(2, this.reconnectAttempt), RECONNECT_MAX_DELAY_MS);
+        const jitter = delay * Math.random() * 0.25;
+        const totalDelay = delay + jitter;
+        this.reconnectAttempt++;
+        console.log(`[ReverseClient] Reconnecting in ${Math.round(totalDelay)}ms (attempt ${this.reconnectAttempt})`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, totalDelay);
+    }
+    resetNoPingTimer() {
+        this.clearNoPingTimer();
+        this.noPingTimer = setTimeout(() => {
+            console.log("[ReverseClient] No ping received in 60s, reconnecting...");
+            if (this.ws) {
+                this.ws.close(1000, "No ping timeout");
+            }
+        }, NO_PING_TIMEOUT_MS);
+    }
+    clearNoPingTimer() {
+        if (this.noPingTimer) {
+            clearTimeout(this.noPingTimer);
+            this.noPingTimer = null;
+        }
+    }
+    closeAllLocalChannels() {
+        for (const [id, ws] of this.localChannels) {
+            try {
+                ws.close(1001, "Control connection closed");
+            }
+            catch { /* ignore */ }
+            this.localChannels.delete(id);
+        }
+    }
+}

package/dist/reverse-connect-manager.d.ts

@@ -0,0 +1,31 @@
+import type WebSocket from "ws";
+import type { VirtualWsAdapter } from "./virtual-ws-adapter.js";
+import type { ProxyResult } from "./utils/remote-proxy.js";
+export interface RawHttpResponse {
+    ok: boolean;
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+}
+export declare class ReverseConnectManager {
+    private connections;
+    private statusChangeHandlers;
+    setStatusChangeHandler(handler: (remoteServerId: string, status: "online" | "offline") => void): void;
+    registerConnection(remoteServerId: string, ws: WebSocket): void;
+    unregisterConnection(remoteServerId: string): void;
+    isConnected(remoteServerId: string): boolean;
+    sendHttpRequest(remoteServerId: string, method: string, path: string, body?: unknown, timeoutMs?: number): Promise<ProxyResult>;
+    /**
+     * Send an HTTP request and return the raw response (body as string, headers intact).
+     * Used by the browser proxy to forward HTML/CSS/JS without JSON parsing.
+     */
+    sendRawHttpRequest(remoteServerId: string, method: string, path: string, headers?: Record<string, string>, body?: string, timeoutMs?: number, port?: number): Promise<RawHttpResponse>;
+    openVirtualChannel(remoteServerId: string, channelId: string, path: string, query?: string): void;
+    sendChannelData(remoteServerId: string, channelId: string, data: string): void;
+    closeChannel(remoteServerId: string, channelId: string, code?: number, reason?: string): void;
+    setChannelAdapter(remoteServerId: string, channelId: string, adapter: VirtualWsAdapter): void;
+    shutdown(): void;
+    private handleFrame;
+    private sendPing;
+    private cleanupConnection;
+}