@vibedeckx/linux-x64 0.1.10

package/dist/routes/browser-proxy-routes.js

@@ -0,0 +1,421 @@
+import { randomUUID } from "crypto";
+import fp from "fastify-plugin";
+import WsWebSocket from "ws";
+import { VirtualWsAdapter } from "../virtual-ws-adapter.js";
+import "../server-types.js";
+/**
+ * Resolve a target URL to either a reverse-connected remote server or a direct URL.
+ *
+ * URL format for reverse-connect: http://{remote-server-name}:{port}/{path}
+ * The hostname is matched against project remote server names (case-insensitive).
+ * If matched, the request is routed through the reverse-connect tunnel as
+ * http://localhost:{port}/{path} on the remote side.
+ */
+export function resolveTarget(targetUrl, projectRemotes, reverseConnectManager) {
+    const parsed = new URL(targetUrl);
+    const hostname = parsed.hostname;
+    // Try to match hostname against project remote server names
+    for (const remote of projectRemotes) {
+        if (remote.server_name.toLowerCase() === hostname.toLowerCase()) {
+            const serverId = remote.remote_server_id;
+            if (reverseConnectManager?.isConnected(serverId)) {
+                // Rewrite to localhost on the remote side, preserving port and path
+                const port = parsed.port || (parsed.protocol === "https:" ? "443" : "80");
+                const localUrl = `http://localhost:${port}${parsed.pathname}${parsed.search}`;
+                return {
+                    remoteServerId: serverId,
+                    fetchUrl: localUrl,
+                    userOrigin: parsed.origin,
+                };
+            }
+        }
+    }
+    // No match or not connected — direct fetch
+    return { remoteServerId: null, fetchUrl: targetUrl, userOrigin: parsed.origin };
+}
+/**
+ * Fetch a URL either directly or via reverse-connect tunnel.
+ */
+async function proxyFetch(resolved, requestHeaders, reverseConnectManager) {
+    if (resolved.remoteServerId && reverseConnectManager?.isConnected(resolved.remoteServerId)) {
+        const parsed = new URL(resolved.fetchUrl);
+        const port = parsed.port ? parseInt(parsed.port, 10) : undefined;
+        const path = parsed.pathname + parsed.search;
+        const raw = await reverseConnectManager.sendRawHttpRequest(resolved.remoteServerId, "GET", path, requestHeaders, undefined, undefined, port);
+        return { status: raw.status, headers: raw.headers, body: raw.body };
+    }
+    // Direct fetch
+    const response = await fetch(resolved.fetchUrl, {
+        headers: requestHeaders,
+        redirect: "follow",
+    });
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+    });
+    const body = await response.text();
+    return { status: response.status, headers: responseHeaders, body };
+}
+/**
+ * Extracts the target URL from the proxy route path.
+ * Route: /api/projects/:id/browser/proxy/https://remote:3000/page
+ * Returns: https://remote:3000/page
+ */
+function extractTargetUrl(requestUrl, projectId) {
+    const prefix = `/api/projects/${projectId}/browser/proxy/`;
+    const idx = requestUrl.indexOf(prefix);
+    if (idx === -1)
+        return null;
+    let target = requestUrl.slice(idx + prefix.length);
+    return decodeURIComponent(target);
+}
+/**
+ * Strips security headers that would block iframe embedding or script injection.
+ */
+function stripSecurityHeaders(headers) {
+    const stripped = { ...headers };
+    const blockedHeaders = [
+        "content-security-policy",
+        "content-security-policy-report-only",
+        "x-frame-options",
+        "x-content-type-options",
+    ];
+    for (const key of blockedHeaders) {
+        delete stripped[key];
+    }
+    return stripped;
+}
+/**
+ * Rewrites URLs in HTML content so relative/absolute paths go through the proxy.
+ */
+function rewriteHtml(html, targetOrigin, proxyPrefix) {
+    // Rewrite absolute paths (href="/...", src="/...")
+    // Match: href="/ or src="/ or action="/ (but not href="//")
+    const attrPattern = /((?:href|src|action|data-src|poster)=["'])\/(?!\/)/gi;
+    let result = html.replace(attrPattern, `$1${proxyPrefix}${targetOrigin}/`);
+    // Rewrite absolute URLs pointing to the target origin
+    const originEscaped = targetOrigin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const originPattern = new RegExp(`((?:href|src|action|data-src|poster)=["'])${originEscaped}`, "gi");
+    result = result.replace(originPattern, `$1${proxyPrefix}${targetOrigin}`);
+    return result;
+}
+/**
+ * Generates the error capture + WebSocket rewriting script to inject into HTML pages.
+ */
+function generateInjectedScript(projectId, targetOrigin, proxyWsPrefix) {
+    return `
+<script data-vibedeckx-injected>
+(function() {
+  var PROJECT_ID = ${JSON.stringify(projectId)};
+  var TARGET_ORIGIN = ${JSON.stringify(targetOrigin)};
+  var WS_PROXY_PREFIX = ${JSON.stringify(proxyWsPrefix)};
+
+  // --- JS Error Capture ---
+  window.addEventListener("error", function(e) {
+    report("js_error", {
+      message: e.message,
+      source: e.filename,
+      line: e.lineno,
+      col: e.colno,
+      stack: e.error ? e.error.stack : null
+    });
+  });
+
+  window.addEventListener("unhandledrejection", function(e) {
+    var reason = e.reason || {};
+    report("promise_rejection", {
+      message: reason.message || String(reason),
+      stack: reason.stack || null
+    });
+  });
+
+  // --- Console Error Capture ---
+  var origError = console.error;
+  console.error = function() {
+    var args = Array.from(arguments);
+    origError.apply(console, args);
+    report("console_error", {
+      message: args.map(function(a) {
+        return typeof a === "object" ? JSON.stringify(a) : String(a);
+      }).join(" ")
+    });
+  };
+
+  // --- Network Error Capture ---
+  var origFetch = window.fetch;
+  window.fetch = function() {
+    var args = arguments;
+    var url = typeof args[0] === "string" ? args[0] : (args[0] && args[0].url ? args[0].url : "");
+    return origFetch.apply(this, args).then(function(res) {
+      if (!res.ok) {
+        report("network_error", { url: url, status: res.status, statusText: res.statusText });
+      }
+      return res;
+    }).catch(function(err) {
+      report("network_error", { url: url, message: err.message });
+      throw err;
+    });
+  };
+
+  // --- WebSocket Rewriting for HMR ---
+  var OrigWebSocket = window.WebSocket;
+  window.WebSocket = function(url, protocols) {
+    var rewritten = url;
+    try {
+      var parsed = new URL(url, location.href);
+      if (parsed.origin === TARGET_ORIGIN || parsed.hostname === new URL(TARGET_ORIGIN).hostname) {
+        var wsScheme = location.protocol === "https:" ? "wss:" : "ws:";
+        rewritten = wsScheme + "//" + location.host + WS_PROXY_PREFIX + parsed.protocol + "//" + parsed.host + parsed.pathname + parsed.search;
+      }
+    } catch(e) { /* keep original URL */ }
+    return protocols !== undefined
+      ? new OrigWebSocket(rewritten, protocols)
+      : new OrigWebSocket(rewritten);
+  };
+  window.WebSocket.prototype = OrigWebSocket.prototype;
+  Object.defineProperty(window.WebSocket, "CONNECTING", { value: OrigWebSocket.CONNECTING });
+  Object.defineProperty(window.WebSocket, "OPEN", { value: OrigWebSocket.OPEN });
+  Object.defineProperty(window.WebSocket, "CLOSING", { value: OrigWebSocket.CLOSING });
+  Object.defineProperty(window.WebSocket, "CLOSED", { value: OrigWebSocket.CLOSED });
+
+  // --- Command Receiver (from parent frame via postMessage) ---
+  window.addEventListener("message", function(e) {
+    if (!e.data || e.data.type !== "vibedeckx-command") return;
+    var cmd = e.data;
+    var result = { type: "vibedeckx-result", id: cmd.id, projectId: PROJECT_ID, success: false };
+    try {
+      switch (cmd.action) {
+        case "click": {
+          var clickEl = document.querySelector(cmd.selector);
+          if (!clickEl) { result.error = "Element not found: " + cmd.selector; break; }
+          clickEl.click();
+          result.success = true;
+          break;
+        }
+        case "fill": {
+          var fillEl = document.querySelector(cmd.selector);
+          if (!fillEl) { result.error = "Element not found: " + cmd.selector; break; }
+          var nativeSetter = Object.getOwnPropertyDescriptor(
+            window.HTMLInputElement.prototype, "value"
+          ) || Object.getOwnPropertyDescriptor(
+            window.HTMLTextAreaElement.prototype, "value"
+          );
+          if (nativeSetter && nativeSetter.set) {
+            nativeSetter.set.call(fillEl, cmd.value);
+          } else {
+            fillEl.value = cmd.value;
+          }
+          fillEl.dispatchEvent(new Event("input", { bubbles: true }));
+          fillEl.dispatchEvent(new Event("change", { bubbles: true }));
+          result.success = true;
+          break;
+        }
+        case "select": {
+          var selectEl = document.querySelector(cmd.selector);
+          if (!selectEl) { result.error = "Element not found: " + cmd.selector; break; }
+          selectEl.value = cmd.value;
+          selectEl.dispatchEvent(new Event("change", { bubbles: true }));
+          result.success = true;
+          break;
+        }
+        case "pressKey": {
+          var target = document.activeElement || document.body;
+          target.dispatchEvent(new KeyboardEvent("keydown", { key: cmd.key, bubbles: true }));
+          target.dispatchEvent(new KeyboardEvent("keypress", { key: cmd.key, bubbles: true }));
+          target.dispatchEvent(new KeyboardEvent("keyup", { key: cmd.key, bubbles: true }));
+          result.success = true;
+          break;
+        }
+        case "getText": {
+          var textEl = cmd.selector ? document.querySelector(cmd.selector) : document.body;
+          if (!textEl) { result.error = "Element not found: " + cmd.selector; break; }
+          result.content = textEl.innerText || textEl.textContent || "";
+          result.success = true;
+          break;
+        }
+        case "getHTML": {
+          var htmlEl = cmd.selector ? document.querySelector(cmd.selector) : document.documentElement;
+          if (!htmlEl) { result.error = "Element not found: " + cmd.selector; break; }
+          result.content = htmlEl.outerHTML;
+          result.success = true;
+          break;
+        }
+        case "querySelector": {
+          var found = document.querySelector(cmd.selector);
+          result.success = true;
+          result.found = !!found;
+          if (found) {
+            result.tag = found.tagName.toLowerCase();
+            result.text = (found.innerText || found.textContent || "").slice(0, 200);
+          }
+          break;
+        }
+        default:
+          result.error = "Unknown action: " + cmd.action;
+      }
+    } catch(err) {
+      result.error = err.message || "Command execution failed";
+    }
+    try {
+      window.parent.postMessage(result, "*");
+    } catch(e) { /* ignore */ }
+  });
+
+  // --- Report to Parent Frame ---
+  function report(type, data) {
+    try {
+      window.parent.postMessage({
+        type: "vibedeckx-browser-error",
+        projectId: PROJECT_ID,
+        error: { type: type, data: data, timestamp: Date.now(), url: location.href }
+      }, "*");
+    } catch(e) { /* ignore */ }
+  }
+})();
+</script>`;
+}
+const routes = async (fastify) => {
+    // --- HTTP Reverse Proxy ---
+    fastify.get("/api/projects/:id/browser/proxy/*", async (req, reply) => {
+        const { id: projectId } = req.params;
+        const targetUrl = extractTargetUrl(req.url, projectId);
+        if (!targetUrl) {
+            return reply.code(400).send({ error: "Invalid proxy URL" });
+        }
+        try {
+            const projectRemotes = fastify.storage.projectRemotes.getByProject(projectId);
+            const resolved = resolveTarget(targetUrl, projectRemotes, fastify.reverseConnectManager);
+            const targetOrigin = resolved.userOrigin;
+            const proxyPrefix = `/api/projects/${projectId}/browser/proxy/`;
+            const proxyWsPrefix = `/api/projects/${projectId}/browser/proxy-ws/`;
+            // Fetch from the remote server (via reverse-connect or direct)
+            const response = await proxyFetch(resolved, {
+                "User-Agent": req.headers["user-agent"] || "Vibedeckx-Proxy/1.0",
+                "Accept": req.headers.accept || "*/*",
+                "Accept-Language": req.headers["accept-language"] || "en",
+                "Cookie": req.headers.cookie || "",
+            }, fastify.reverseConnectManager);
+            const contentType = response.headers["content-type"] || "";
+            // Strip security headers
+            const safeHeaders = stripSecurityHeaders(response.headers);
+            // Add proxy identifier
+            safeHeaders["x-vibedeckx-proxy"] = "true";
+            // Remove content-encoding since we may modify the body
+            delete safeHeaders["content-encoding"];
+            delete safeHeaders["content-length"];
+            // Set headers on reply
+            for (const [key, value] of Object.entries(safeHeaders)) {
+                reply.header(key, value);
+            }
+            if (contentType.includes("text/html")) {
+                // HTML response — rewrite URLs and inject script
+                let html = response.body;
+                html = rewriteHtml(html, targetOrigin, proxyPrefix);
+                // Inject error capture script before </body> or at end
+                const script = generateInjectedScript(projectId, targetOrigin, proxyWsPrefix);
+                if (html.includes("</body>")) {
+                    html = html.replace("</body>", script + "</body>");
+                }
+                else {
+                    html += script;
+                }
+                return reply.code(response.status).type("text/html").send(html);
+            }
+            if (contentType.includes("text/css")) {
+                // CSS response — rewrite url() references
+                let css = response.body;
+                css = css.replace(/url\(\s*['"]?\//g, `url(${proxyPrefix}${targetOrigin}/`);
+                return reply.code(response.status).type("text/css").send(css);
+            }
+            // Non-HTML/CSS — pass through as-is
+            return reply.code(response.status).send(response.body);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Proxy request failed";
+            console.error(`[BrowserProxy] Error proxying ${targetUrl}:`, msg);
+            return reply.code(502).send({ error: `Proxy error: ${msg}` });
+        }
+    });
+    // --- WebSocket Reverse Proxy (for HMR) ---
+    fastify.get("/api/projects/:id/browser/proxy-ws/*", { websocket: true }, (socket, req) => {
+        const { id: projectId } = req.params;
+        const rawPath = req.url;
+        const prefix = `/api/projects/${projectId}/browser/proxy-ws/`;
+        const idx = rawPath.indexOf(prefix);
+        if (idx === -1) {
+            socket.close(4000, "Invalid proxy-ws URL");
+            return;
+        }
+        const targetWsUrl = decodeURIComponent(rawPath.slice(idx + prefix.length));
+        console.log(`[BrowserProxy] WS proxy: ${targetWsUrl}`);
+        // Resolve hostname to remote server
+        const projectRemotes = fastify.storage.projectRemotes.getByProject(projectId);
+        const resolved = resolveTarget(targetWsUrl, projectRemotes, fastify.reverseConnectManager);
+        const rcm = fastify.reverseConnectManager;
+        if (resolved.remoteServerId && rcm.isConnected(resolved.remoteServerId)) {
+            // Route via reverse-connect virtual channel
+            const remoteServerId = resolved.remoteServerId;
+            const channelId = randomUUID();
+            const parsed = new URL(resolved.fetchUrl);
+            const wsPath = parsed.pathname;
+            const wsQuery = parsed.search ? parsed.search.slice(1) : undefined;
+            const adapter = new VirtualWsAdapter((data) => rcm.sendChannelData(remoteServerId, channelId, data), () => rcm.closeChannel(remoteServerId, channelId));
+            rcm.setChannelAdapter(remoteServerId, channelId, adapter);
+            rcm.openVirtualChannel(remoteServerId, channelId, wsPath, wsQuery);
+            // Bidirectional pipe via virtual channel
+            socket.on("message", (data) => {
+                adapter.send(data.toString());
+            });
+            adapter.on("message", (data) => {
+                try {
+                    socket.send(data);
+                }
+                catch { /* client gone */ }
+            });
+            socket.on("close", () => {
+                adapter.close();
+            });
+            adapter.on("close", () => {
+                try {
+                    socket.close();
+                }
+                catch { /* ignore */ }
+            });
+            return;
+        }
+        // Direct WebSocket connection
+        const remote = new WsWebSocket(targetWsUrl);
+        remote.on("open", () => {
+            console.log(`[BrowserProxy] WS proxy connected to ${targetWsUrl}`);
+        });
+        // Bidirectional pipe
+        socket.on("message", (data) => {
+            if (remote.readyState === WsWebSocket.OPEN) {
+                remote.send(data);
+            }
+        });
+        remote.on("message", (data) => {
+            try {
+                socket.send(data);
+            }
+            catch { /* client gone */ }
+        });
+        socket.on("close", () => {
+            remote.close();
+        });
+        remote.on("close", () => {
+            try {
+                socket.close();
+            }
+            catch { /* ignore */ }
+        });
+        remote.on("error", (err) => {
+            console.error(`[BrowserProxy] WS proxy error for ${targetWsUrl}:`, err.message);
+            try {
+                socket.close(4002, "Remote WS error");
+            }
+            catch { /* ignore */ }
+        });
+    });
+};
+export default fp(routes, { name: "browser-proxy-routes" });

package/dist/routes/browser-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyPluginAsync } from "fastify";
+import "../server-types.js";
+declare const _default: FastifyPluginAsync;
+export default _default;

package/dist/routes/browser-routes.js

@@ -0,0 +1,73 @@
+import fp from "fastify-plugin";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+const routes = async (fastify) => {
+    // Start browser session
+    fastify.post("/api/projects/:id/browser", async (req, reply) => {
+        if (requireAuth(req, reply) === null)
+            return;
+        const { id: projectId } = req.params;
+        const { branch } = req.body || {};
+        try {
+            const session = await fastify.browserManager.startSession(projectId, branch ?? null);
+            return reply.code(200).send(session);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Failed to start browser";
+            return reply.code(500).send({ error: msg });
+        }
+    });
+    // Get browser session status
+    fastify.get("/api/projects/:id/browser", async (req, reply) => {
+        if (requireAuth(req, reply) === null)
+            return;
+        const { id: projectId } = req.params;
+        const session = fastify.browserManager.getSession(projectId);
+        if (!session) {
+            return reply.code(404).send({ error: "No browser session" });
+        }
+        return reply.code(200).send(session);
+    });
+    // Stop browser session
+    fastify.delete("/api/projects/:id/browser", async (req, reply) => {
+        if (requireAuth(req, reply) === null)
+            return;
+        const { id: projectId } = req.params;
+        const stopped = await fastify.browserManager.stopSession(projectId);
+        if (!stopped) {
+            return reply.code(404).send({ error: "No browser session to stop" });
+        }
+        return reply.code(200).send({ ok: true });
+    });
+    // Navigate browser to URL
+    fastify.post("/api/projects/:id/browser/navigate", async (req, reply) => {
+        if (requireAuth(req, reply) === null)
+            return;
+        const { id: projectId } = req.params;
+        const { url } = req.body;
+        if (!url) {
+            return reply.code(400).send({ error: "URL is required" });
+        }
+        try {
+            const result = await fastify.browserManager.navigate(projectId, url);
+            if (!result) {
+                return reply.code(404).send({ error: "No browser session. Start one first." });
+            }
+            return reply.code(200).send(result);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "Navigation failed";
+            return reply.code(500).send({ error: msg });
+        }
+    });
+    // Report browser error from injected script
+    fastify.post("/api/projects/:id/browser/error", async (req, reply) => {
+        if (requireAuth(req, reply) === null)
+            return;
+        const { id: projectId } = req.params;
+        const { type, data } = req.body;
+        console.log(`[BrowserRoutes] Error report for project ${projectId}: ${type}`, data);
+        return reply.code(200).send({ ok: true });
+    });
+};
+export default fp(routes, { name: "browser-routes" });

package/dist/routes/chat-session-routes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * REST routes for chat sessions (AI SDK chat, not Claude Code agent).
+ */
+import type { FastifyPluginAsync } from "fastify";
+import "../server-types.js";
+declare const _default: FastifyPluginAsync;
+export default _default;

package/dist/routes/chat-session-routes.js

@@ -0,0 +1,69 @@
+/**
+ * REST routes for chat sessions (AI SDK chat, not Claude Code agent).
+ */
+import fp from "fastify-plugin";
+import { requireAuth } from "../server.js";
+import "../server-types.js";
+const routes = async (fastify) => {
+    // Create or get existing chat session for a project+branch
+    fastify.post("/api/projects/:projectId/chat-sessions", async (req, reply) => {
+        const userId = requireAuth(req, reply);
+        if (userId === null)
+            return;
+        const { projectId } = req.params;
+        const branch = req.body?.branch ?? null;
+        const sessionId = fastify.chatSessionManager.getOrCreateSession(projectId, branch);
+        const session = fastify.chatSessionManager.getSession(sessionId);
+        const messages = fastify.chatSessionManager.getMessages(sessionId);
+        return reply.send({
+            session: {
+                id: session.id,
+                projectId: session.projectId,
+                branch: session.branch,
+                status: session.status,
+                eventListeningEnabled: session.eventListeningEnabled,
+            },
+            messages,
+        });
+    });
+    // Send a user message (triggers AI streaming)
+    fastify.post("/api/chat-sessions/:sessionId/message", async (req, reply) => {
+        const { sessionId } = req.params;
+        const { content } = req.body;
+        if (!content?.trim()) {
+            return reply.code(400).send({ error: "Message content is required" });
+        }
+        const session = fastify.chatSessionManager.getSession(sessionId);
+        if (!session) {
+            return reply.code(404).send({ error: "Session not found" });
+        }
+        // Fire and forget — response streams over WebSocket
+        fastify.chatSessionManager.sendMessage(sessionId, content.trim()).catch((err) => {
+            console.error(`[ChatRoutes] sendMessage error for ${sessionId}:`, err);
+        });
+        return reply.send({ ok: true });
+    });
+    // Toggle event listening for a chat session
+    fastify.post("/api/chat-sessions/:sessionId/event-listening", async (req, reply) => {
+        const { sessionId } = req.params;
+        const { enabled } = req.body;
+        if (typeof enabled !== "boolean") {
+            return reply.code(400).send({ error: "enabled must be a boolean" });
+        }
+        const success = fastify.chatSessionManager.setEventListening(sessionId, enabled);
+        if (!success) {
+            return reply.code(404).send({ error: "Session not found" });
+        }
+        return reply.send({ enabled });
+    });
+    // Stop current generation
+    fastify.post("/api/chat-sessions/:sessionId/stop", async (req, reply) => {
+        const { sessionId } = req.params;
+        const stopped = fastify.chatSessionManager.stopGeneration(sessionId);
+        if (!stopped) {
+            return reply.code(404).send({ error: "Session not found or not generating" });
+        }
+        return reply.send({ ok: true });
+    });
+};
+export default fp(routes, { name: "chat-session-routes" });

package/dist/routes/diff-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyPluginAsync } from "fastify";
+import "../server-types.js";
+declare const _default: FastifyPluginAsync;
+export default _default;