@vibedeckx/linux-x64 0.1.10

package/dist/utils/remote-proxy.js

@@ -0,0 +1,145 @@
+import { randomUUID } from "crypto";
+let globalProxyManager;
+export function setGlobalProxyManager(pm) {
+    globalProxyManager = pm;
+}
+const TRANSIENT_STATUS_CODES = new Set([502, 503, 504]);
+const MAX_RETRIES = 5;
+const RETRY_BASE_DELAY_MS = 500;
+const RETRY_MAX_DELAY_MS = 8000;
+function isTransientError(result) {
+    return (result.errorCode === "network_error" ||
+        result.errorCode === "non_json_response" ||
+        TRANSIENT_STATUS_CODES.has(result.status));
+}
+async function proxyOnce(baseUrl, apiKey, method, apiPath, body, requestId, timeoutMs, dispatcher) {
+    const start = Date.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const headers = {
+            "X-Vibedeckx-Api-Key": apiKey,
+            "X-Request-Id": requestId,
+            "User-Agent": "Vibedeckx/1.0",
+        };
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+        }
+        const effectiveDispatcher = dispatcher ?? globalProxyManager?.getFetchDispatcher();
+        const fetchOptions = {
+            method,
+            headers,
+            body: body !== undefined ? JSON.stringify(body) : undefined,
+            signal: controller.signal,
+        };
+        if (effectiveDispatcher) {
+            fetchOptions.dispatcher = effectiveDispatcher;
+        }
+        const response = await fetch(`${baseUrl}${apiPath}`, fetchOptions);
+        const durationMs = Date.now() - start;
+        console.log(`[proxyToRemote] ${requestId} -> ${response.status} (${durationMs}ms)`);
+        const contentType = response.headers.get("content-type") || "";
+        if (contentType.includes("application/json")) {
+            const data = await response.json();
+            let errorCode;
+            if (!response.ok) {
+                if (response.status === 401)
+                    errorCode = "auth_error";
+                else if (response.status >= 500)
+                    errorCode = "server_error";
+            }
+            return { ok: response.ok, status: response.status, data, errorCode, requestId, durationMs };
+        }
+        else {
+            const text = await response.text();
+            const data = { error: `Non-JSON response (${response.status}): ${text.slice(0, 200)}` };
+            return { ok: false, status: response.status, data, errorCode: "non_json_response", requestId, durationMs };
+        }
+    }
+    catch (error) {
+        const durationMs = Date.now() - start;
+        const message = error instanceof Error ? error.message : "Connection failed";
+        console.error(`[proxyToRemote] ${requestId} FAILED: ${message} (${durationMs}ms)`);
+        let errorCode = "network_error";
+        if (error instanceof Error && error.name === "AbortError") {
+            errorCode = "timeout";
+        }
+        return {
+            ok: false,
+            status: 0,
+            data: { error: errorCode === "timeout" ? `Request timed out after ${timeoutMs}ms` : message },
+            errorCode,
+            requestId,
+            durationMs,
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function proxyToRemote(remoteUrl, apiKey, method, apiPath, body, options) {
+    const requestId = options?.requestId ?? randomUUID();
+    const timeoutMs = options?.timeoutMs ?? 30_000;
+    const baseUrl = remoteUrl.replace(/\/+$/, "");
+    const totalStart = Date.now();
+    console.log(`[proxyToRemote] ${requestId} ${method} ${baseUrl}${apiPath}`);
+    let result = await proxyOnce(baseUrl, apiKey, method, apiPath, body, requestId, timeoutMs, options?.dispatcher);
+    let attempts = 1;
+    for (let attempt = 1; attempt <= MAX_RETRIES && isTransientError(result); attempt++) {
+        const delay = Math.min(RETRY_BASE_DELAY_MS * Math.pow(2, attempt - 1), RETRY_MAX_DELAY_MS);
+        console.log(`[proxyToRemote] ${requestId} retrying (${attempt}/${MAX_RETRIES}) after ${delay}ms...` +
+            ` (last error: ${result.errorCode}, status: ${result.status})`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        result = await proxyOnce(baseUrl, apiKey, method, apiPath, body, requestId, timeoutMs, options?.dispatcher);
+        attempts++;
+    }
+    const totalDurationMs = Date.now() - totalStart;
+    result.attempts = attempts;
+    result.totalDurationMs = totalDurationMs;
+    if (!result.ok) {
+        console.error(`[proxyToRemote] ${requestId} EXHAUSTED after ${attempts} attempt(s) in ${totalDurationMs}ms.` +
+            ` Final error: ${result.errorCode}, status: ${result.status},` +
+            ` data: ${JSON.stringify(result.data).substring(0, 300)}`);
+    }
+    return result;
+}
+/**
+ * Auto-routing proxy: if a ReverseConnectManager is provided and the remote
+ * is connected via reverse-connect, routes through the control channel.
+ * Otherwise falls back to the standard outbound HTTP proxy.
+ */
+export async function proxyToRemoteAuto(remoteServerId, remoteUrl, apiKey, method, apiPath, body, options) {
+    const rcm = options?.reverseConnectManager;
+    if (rcm && rcm.isConnected(remoteServerId)) {
+        return rcm.sendHttpRequest(remoteServerId, method, apiPath, body, options?.timeoutMs);
+    }
+    return proxyToRemote(remoteUrl, apiKey, method, apiPath, body, options);
+}
+export async function proxyToRemoteRaw(remoteUrl, apiKey, apiPath, options) {
+    const baseUrl = remoteUrl.replace(/\/+$/, "");
+    const timeoutMs = options?.timeoutMs ?? 30_000;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const effectiveDispatcher = options?.dispatcher ?? globalProxyManager?.getFetchDispatcher();
+        const fetchOptions = {
+            method: "GET",
+            headers: {
+                "X-Vibedeckx-Api-Key": apiKey,
+                "User-Agent": "Vibedeckx/1.0",
+            },
+            signal: controller.signal,
+        };
+        if (effectiveDispatcher) {
+            fetchOptions.dispatcher = effectiveDispatcher;
+        }
+        const response = await fetch(`${baseUrl}${apiPath}`, fetchOptions);
+        return { ok: response.ok, status: response.status, body: response.body };
+    }
+    catch {
+        return { ok: false, status: 0, body: null };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}

package/dist/utils/worktree-paths.d.ts

@@ -0,0 +1,13 @@
+/** Resolve branch to absolute filesystem path. null = main worktree. */
+export declare function resolveWorktreePath(projectPath: string, branch: string | null): string;
+/** Get the base worktree directory for a project (for mkdir) */
+export declare function getWorktreeBaseForProject(projectPath: string): string;
+/** Parse `git worktree list --porcelain` output into structured entries */
+export declare function parseGitWorktreeList(projectPath: string): Array<{
+    path: string;
+    branch: string | null;
+}>;
+/** Get worktree branches for a project in the API response shape */
+export declare function getWorktreeBranches(projectPath: string): Array<{
+    branch: string | null;
+}>;

package/dist/utils/worktree-paths.js

@@ -0,0 +1,64 @@
+import path from "path";
+import { createHash } from "crypto";
+import { execSync } from "child_process";
+const WORKTREE_BASE_DIR = "/var/tmp/vibedeckx/worktrees";
+/** Stable short identifier for a project path */
+function getProjectIdentifier(projectPath) {
+    const basename = path.basename(projectPath);
+    const hash = createHash("md5").update(projectPath).digest("hex").slice(0, 8);
+    return `${basename}-${hash}`;
+}
+/** Resolve branch to absolute filesystem path. null = main worktree. */
+export function resolveWorktreePath(projectPath, branch) {
+    if (!branch)
+        return projectPath;
+    const dirName = branch.replace(/\//g, "-");
+    return path.join(WORKTREE_BASE_DIR, getProjectIdentifier(projectPath), dirName);
+}
+/** Get the base worktree directory for a project (for mkdir) */
+export function getWorktreeBaseForProject(projectPath) {
+    return path.join(WORKTREE_BASE_DIR, getProjectIdentifier(projectPath));
+}
+/** Parse `git worktree list --porcelain` output into structured entries */
+export function parseGitWorktreeList(projectPath) {
+    execSync("git worktree prune", {
+        cwd: projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    const output = execSync("git worktree list --porcelain", {
+        cwd: projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    const entries = [];
+    const blocks = output.trim().split("\n\n");
+    for (const block of blocks) {
+        const lines = block.split("\n");
+        let worktreePath = "";
+        let branch = null;
+        for (const line of lines) {
+            if (line.startsWith("worktree "))
+                worktreePath = line.slice(9);
+            else if (line.startsWith("branch refs/heads/"))
+                branch = line.slice(18);
+        }
+        if (worktreePath) {
+            entries.push({ path: worktreePath, branch });
+        }
+    }
+    return entries;
+}
+/** Get worktree branches for a project in the API response shape */
+export function getWorktreeBranches(projectPath) {
+    const entries = parseGitWorktreeList(projectPath);
+    const worktrees = [{ branch: null }];
+    // The first entry (index 0) is always the main worktree — skip it.
+    // Add all other worktrees that have a branch name.
+    for (let i = 1; i < entries.length; i++) {
+        if (entries[i].branch) {
+            worktrees.push({ branch: entries[i].branch });
+        }
+    }
+    return worktrees;
+}

package/dist/virtual-ws-adapter.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from "events";
+/**
+ * A virtual WebSocket adapter that duck-types the WebSocket interface.
+ * Used so that inbound remote connections can use the same code paths
+ * as real WebSocket connections in websocket-routes.ts.
+ */
+export declare class VirtualWsAdapter extends EventEmitter {
+    static readonly OPEN = 1;
+    static readonly CLOSED = 3;
+    readyState: number;
+    private readonly sendFn;
+    private readonly closeFn;
+    constructor(sendFn: (data: string) => void, closeFn: () => void);
+    /** Send data to the remote side via the provided callback. */
+    send(data: string | Buffer): void;
+    /** Close the virtual connection. */
+    close(code?: number, reason?: string): void;
+    /** No-op for virtual connections. */
+    ping(): void;
+    /** Simulate receiving a message from the remote side. */
+    deliverMessage(data: string): void;
+    /** Simulate the remote side closing the connection. */
+    deliverClose(code?: number, reason?: string): void;
+    /** Simulate an error on the connection. */
+    deliverError(error: Error): void;
+}

package/dist/virtual-ws-adapter.js

@@ -0,0 +1,54 @@
+import { EventEmitter } from "events";
+/**
+ * A virtual WebSocket adapter that duck-types the WebSocket interface.
+ * Used so that inbound remote connections can use the same code paths
+ * as real WebSocket connections in websocket-routes.ts.
+ */
+export class VirtualWsAdapter extends EventEmitter {
+    static OPEN = 1;
+    static CLOSED = 3;
+    readyState = VirtualWsAdapter.OPEN;
+    sendFn;
+    closeFn;
+    constructor(sendFn, closeFn) {
+        super();
+        this.sendFn = sendFn;
+        this.closeFn = closeFn;
+    }
+    /** Send data to the remote side via the provided callback. */
+    send(data) {
+        if (this.readyState !== VirtualWsAdapter.OPEN)
+            return;
+        const str = typeof data === "string" ? data : data.toString("utf-8");
+        this.sendFn(str);
+    }
+    /** Close the virtual connection. */
+    close(code, reason) {
+        if (this.readyState === VirtualWsAdapter.CLOSED)
+            return;
+        this.readyState = VirtualWsAdapter.CLOSED;
+        this.closeFn();
+        this.emit("close", code ?? 1000, reason ?? "");
+    }
+    /** No-op for virtual connections. */
+    ping() {
+        // no-op
+    }
+    /** Simulate receiving a message from the remote side. */
+    deliverMessage(data) {
+        if (this.readyState !== VirtualWsAdapter.OPEN)
+            return;
+        this.emit("message", data);
+    }
+    /** Simulate the remote side closing the connection. */
+    deliverClose(code, reason) {
+        if (this.readyState === VirtualWsAdapter.CLOSED)
+            return;
+        this.readyState = VirtualWsAdapter.CLOSED;
+        this.emit("close", code ?? 1000, reason ?? "");
+    }
+    /** Simulate an error on the connection. */
+    deliverError(error) {
+        this.emit("error", error);
+    }
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@vibedeckx/linux-x64",
+  "version": "0.1.10",
+  "description": "Vibedeckx platform binaries for Linux x64",
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "type": "module",
+  "bin": {
+    "vibedeckx": "./dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "node_modules"
+  ]
+}