@vibedeckx/linux-x64 0.1.10

package/dist/providers/claude-code-provider.d.ts

@@ -0,0 +1,13 @@
+import type { AgentType, ContentPart } from "../agent-types.js";
+import type { AgentProvider, SpawnConfig, ParsedAgentEvent } from "../agent-provider.js";
+export declare class ClaudeCodeProvider implements AgentProvider {
+    private binaryPath;
+    getAgentType(): AgentType;
+    getDisplayName(): string;
+    detectBinary(): string | null;
+    buildSpawnConfig(_cwd: string, permissionMode: "plan" | "edit"): SpawnConfig;
+    parseStdoutLine(line: string, _sessionId: string): ParsedAgentEvent[];
+    formatUserInput(content: string | ContentPart[], _sessionId: string): string;
+    onSessionCreated(_sessionId: string): void;
+    onSessionDestroyed(_sessionId: string): void;
+}

package/dist/providers/claude-code-provider.js

@@ -0,0 +1,127 @@
+import { execFileSync } from "child_process";
+export class ClaudeCodeProvider {
+    binaryPath = undefined;
+    getAgentType() {
+        return "claude-code";
+    }
+    getDisplayName() {
+        return "Claude Code";
+    }
+    detectBinary() {
+        if (this.binaryPath !== undefined) {
+            return this.binaryPath;
+        }
+        try {
+            const cmd = process.platform === "win32" ? "where" : "which";
+            const result = execFileSync(cmd, ["claude"], {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "ignore"],
+            }).trim();
+            this.binaryPath = result || null;
+            console.log(`[ClaudeCodeProvider] Native claude binary found: ${result}`);
+        }
+        catch {
+            this.binaryPath = null;
+            console.log(`[ClaudeCodeProvider] Native claude binary not found, will use npx`);
+        }
+        return this.binaryPath;
+    }
+    buildSpawnConfig(_cwd, permissionMode) {
+        const nativeBinary = this.detectBinary();
+        const permissionFlag = permissionMode === "plan"
+            ? "--permission-mode=plan"
+            : "--dangerously-skip-permissions";
+        const claudeArgs = [
+            "--output-format=stream-json",
+            "--input-format=stream-json",
+            permissionFlag,
+            "--verbose",
+        ];
+        if (nativeBinary) {
+            return { command: nativeBinary, args: claudeArgs };
+        }
+        return {
+            command: "npx",
+            args: ["-y", "@anthropic-ai/claude-code", ...claudeArgs],
+        };
+    }
+    parseStdoutLine(line, _sessionId) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return [];
+        }
+        if (msg.type === "user") {
+            return [];
+        }
+        if (msg.type === "assistant") {
+            const content = msg.message?.content;
+            if (!content)
+                return [];
+            const events = [];
+            for (const block of content) {
+                switch (block.type) {
+                    case "text":
+                        events.push({ type: "text", content: block.text });
+                        break;
+                    case "tool_use":
+                        events.push({ type: "tool_use", tool: block.name, input: block.input, toolUseId: block.id });
+                        break;
+                    case "tool_result":
+                        events.push({
+                            type: "tool_result",
+                            tool: "",
+                            output: typeof block.content === "string" ? block.content : JSON.stringify(block.content),
+                            toolUseId: block.tool_use_id,
+                        });
+                        break;
+                    case "thinking":
+                        events.push({ type: "thinking", content: block.thinking });
+                        break;
+                }
+            }
+            return events;
+        }
+        if (msg.type === "system") {
+            const systemMsg = msg;
+            if (systemMsg.message) {
+                return [{ type: "system", content: systemMsg.message }];
+            }
+            return [];
+        }
+        if (msg.type === "result") {
+            const resultMsg = msg;
+            const events = [];
+            if (resultMsg.subtype === "error" && resultMsg.error) {
+                events.push({ type: "error", message: resultMsg.error });
+            }
+            events.push({
+                type: "result",
+                subtype: resultMsg.subtype === "error" ? "error" : "success",
+                error: resultMsg.error,
+                duration_ms: resultMsg.duration_ms,
+                cost_usd: resultMsg.cost_usd,
+            });
+            return events;
+        }
+        return [];
+    }
+    formatUserInput(content, _sessionId) {
+        if (typeof content === "string") {
+            return JSON.stringify({ type: "user", message: { role: "user", content } }) + "\n";
+        }
+        // Map ContentPart[] to Claude's content block format
+        const blocks = content.map((part) => {
+            if (part.type === "text") {
+                return { type: "text", text: part.text };
+            }
+            return { type: "image", source: { type: "base64", media_type: part.mediaType, data: part.data } };
+        });
+        return JSON.stringify({ type: "user", message: { role: "user", content: blocks } }) + "\n";
+    }
+    // Lifecycle hooks are no-ops for Claude (stateless per-session)
+    onSessionCreated(_sessionId) { }
+    onSessionDestroyed(_sessionId) { }
+}

package/dist/providers/codex-provider.d.ts

@@ -0,0 +1,41 @@
+import type { AgentType, ContentPart } from "../agent-types.js";
+import type { AgentProvider, SpawnConfig, ParsedAgentEvent } from "../agent-provider.js";
+interface CodexSessionState {
+    threadId: string | null;
+    rpcIdCounter: number;
+    initialized: boolean;
+    pendingRequests: Map<number, string>;
+    permissionMode: "plan" | "edit";
+    /** Buffered first-turn content, sent after thread/start response provides threadId */
+    pendingTurnContent: string | ContentPart[] | null;
+}
+export declare class CodexProvider implements AgentProvider {
+    private binaryPath;
+    private sessions;
+    private static idCounter;
+    private lastPermissionMode;
+    getAgentType(): AgentType;
+    getDisplayName(): string;
+    detectBinary(): string | null;
+    buildSpawnConfig(_cwd: string, permissionMode: "plan" | "edit"): SpawnConfig;
+    parseStdoutLine(line: string, sessionId: string): ParsedAgentEvent[];
+    private handleNotification;
+    private handleItemCompleted;
+    private handleTurnCompleted;
+    private handleTokenUsage;
+    private handleServerRequest;
+    getInitializationMessages(sessionId: string): string | null;
+    formatUserInput(content: string | ContentPart[], sessionId: string): string;
+    /** Build params for thread/start — uses `sandbox` (string enum) per ThreadStartParams schema */
+    private buildThreadStartParams;
+    formatApprovalResponse(requestId: string, decision: string, _sessionId: string): string;
+    formatInterrupt(sessionId: string): string | null;
+    onSessionCreated(sessionId: string): void;
+    onSessionDestroyed(sessionId: string): void;
+    /** Get session state, creating default if missing (defensive). */
+    getSessionState(sessionId: string): CodexSessionState;
+    /** Build Codex input array from string or ContentPart[] */
+    private buildCodexInput;
+    private generateId;
+}
+export {};

package/dist/providers/codex-provider.js

@@ -0,0 +1,354 @@
+import { execFileSync } from "child_process";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class CodexProvider {
+    binaryPath = undefined;
+    sessions = new Map();
+    static idCounter = 0;
+    lastPermissionMode = "edit";
+    getAgentType() {
+        return "codex";
+    }
+    getDisplayName() {
+        return "Codex";
+    }
+    detectBinary() {
+        if (this.binaryPath !== undefined) {
+            return this.binaryPath;
+        }
+        try {
+            const cmd = process.platform === "win32" ? "where" : "which";
+            const result = execFileSync(cmd, ["codex"], {
+                encoding: "utf-8",
+                stdio: ["pipe", "pipe", "ignore"],
+            }).trim();
+            this.binaryPath = result || null;
+            console.log(`[CodexProvider] Native codex binary found: ${result}`);
+        }
+        catch {
+            this.binaryPath = null;
+            console.log(`[CodexProvider] Native codex binary not found, will use npx`);
+        }
+        return this.binaryPath;
+    }
+    buildSpawnConfig(_cwd, permissionMode) {
+        // Store permissionMode for use in formatUserInput's turn/start params (task 5.12)
+        this.lastPermissionMode = permissionMode;
+        const nativeBinary = this.detectBinary();
+        if (nativeBinary) {
+            return { command: nativeBinary, args: ["app-server"], shell: false };
+        }
+        return {
+            command: "npx",
+            args: ["-y", "@openai/codex", "app-server"],
+            shell: false,
+        };
+    }
+    // ============ Task 5.5: parseStdoutLine — JSON-RPC message routing ============
+    parseStdoutLine(line, sessionId) {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            return [];
+        }
+        const state = this.getSessionState(sessionId);
+        // (a) Response: has id + result, no method
+        if (msg.id != null && !msg.method && msg.result !== undefined) {
+            const reqMethod = state.pendingRequests.get(Number(msg.id));
+            state.pendingRequests.delete(Number(msg.id));
+            // Extract threadId from thread/start response
+            if (reqMethod === "thread/start" && msg.result?.thread?.id) {
+                state.threadId = msg.result.thread.id;
+                // Send buffered first turn now that we have threadId
+                if (state.pendingTurnContent !== null) {
+                    const content = state.pendingTurnContent;
+                    state.pendingTurnContent = null;
+                    const id = state.rpcIdCounter++;
+                    state.pendingRequests.set(id, "turn/start");
+                    const turnMsg = JSON.stringify({
+                        jsonrpc: "2.0",
+                        id,
+                        method: "turn/start",
+                        params: { threadId: state.threadId, input: this.buildCodexInput(content) },
+                    }) + "\n";
+                    return [{ type: "stdin_write", content: turnMsg }];
+                }
+            }
+            return [];
+        }
+        // (c) Server request: has id + method (check before notifications since both have method)
+        if (msg.id != null && msg.method) {
+            return this.handleServerRequest(msg);
+        }
+        // (b) Notification: has method, no id
+        if (msg.method) {
+            return this.handleNotification(msg);
+        }
+        return [];
+    }
+    // ============ Notification routing ============
+    handleNotification(msg) {
+        const params = msg.params;
+        switch (msg.method) {
+            case "item/completed":
+                return this.handleItemCompleted(params?.item);
+            case "turn/completed":
+                return this.handleTurnCompleted(params);
+            case "thread/tokenUsage/updated":
+                return this.handleTokenUsage(params);
+            default:
+                return [];
+        }
+    }
+    // ============ Task 5.6: item/completed — ThreadItem parsing ============
+    handleItemCompleted(item) {
+        if (!item?.type)
+            return [];
+        switch (item.type) {
+            case "agentMessage":
+                return [{ type: "text", content: item.text ?? "" }];
+            case "reasoning": {
+                const parts = item.summary ?? item.content ?? [];
+                const text = parts.join("\n");
+                if (!text)
+                    return [];
+                return [{ type: "thinking", content: text }];
+            }
+            case "userMessage":
+                // Codex echoes the user's input — already rendered by sendUserMessage, skip
+                return [];
+            case "commandExecution": {
+                const id = item.id ?? this.generateId();
+                return [
+                    { type: "tool_use", tool: "Bash", input: { command: item.command }, toolUseId: id },
+                    { type: "tool_result", tool: "Bash", output: item.aggregatedOutput ?? "", toolUseId: id },
+                ];
+            }
+            case "fileChange": {
+                const id = item.id ?? this.generateId();
+                const changes = (item.changes ?? []).map((c) => ({
+                    path: c.path,
+                    diff: c.diff,
+                    kind: typeof c.kind === "object" ? c.kind.type : String(c.kind),
+                }));
+                return [
+                    { type: "tool_use", tool: "FileChange", input: { changes }, toolUseId: id },
+                    { type: "tool_result", tool: "FileChange", output: item.status ?? "completed", toolUseId: id },
+                ];
+            }
+            case "plan":
+                return [{ type: "text", content: item.text ?? "" }];
+            case "webSearch": {
+                const id = item.id ?? this.generateId();
+                return [{ type: "tool_use", tool: "WebSearch", input: { query: item.query }, toolUseId: id }];
+            }
+            case "mcpToolCall": {
+                const id = item.id ?? this.generateId();
+                const toolName = item.tool ?? "MCP";
+                const output = item.error?.message ?? (item.result ? JSON.stringify(item.result) : "");
+                return [
+                    { type: "tool_use", tool: toolName, input: item.arguments, toolUseId: id },
+                    { type: "tool_result", tool: toolName, output, toolUseId: id },
+                ];
+            }
+            case "collabAgentToolCall": {
+                const id = item.id ?? this.generateId();
+                return [
+                    { type: "tool_use", tool: "Agent", input: { tool: item.tool, prompt: item.prompt }, toolUseId: id },
+                ];
+            }
+            default:
+                // imageView, contextCompaction, enteredReviewMode, exitedReviewMode, dynamicToolCall, etc.
+                return [{ type: "system", content: `[${item.type}]` }];
+        }
+    }
+    // ============ Task 5.7: turn/completed ============
+    handleTurnCompleted(params) {
+        const turn = params?.turn;
+        if (!turn)
+            return [];
+        return [{
+                type: "result",
+                subtype: turn.status === "completed" ? "success" : "error",
+                error: turn.error?.message,
+            }];
+    }
+    // ============ Task 5.8: thread/tokenUsage/updated ============
+    handleTokenUsage(params) {
+        const usage = params?.tokenUsage;
+        if (!usage)
+            return [];
+        const last = usage.last;
+        if (!last)
+            return [];
+        return [{
+                type: "result",
+                subtype: "success",
+                input_tokens: last.inputTokens,
+                output_tokens: last.outputTokens,
+            }];
+    }
+    // ============ Task 5.9: Server requests (approvals) ============
+    handleServerRequest(msg) {
+        const params = msg.params;
+        switch (msg.method) {
+            case "item/commandExecution/requestApproval":
+                return [{
+                        type: "approval_request",
+                        requestType: "command",
+                        requestId: String(msg.id),
+                        command: params?.command ?? "",
+                        cwd: params?.cwd,
+                    }];
+            case "item/fileChange/requestApproval":
+                return [{
+                        type: "approval_request",
+                        requestType: "fileChange",
+                        requestId: String(msg.id),
+                        changes: params?.changes ?? [],
+                    }];
+            case "item/tool/requestUserInput":
+                return [{
+                        type: "tool_use",
+                        tool: "AskUserQuestion",
+                        input: { questions: params?.questions },
+                        toolUseId: String(msg.id),
+                    }];
+            default:
+                return [];
+        }
+    }
+    // ============ Pre-initialization: send initialize + thread/start right after spawn ============
+    getInitializationMessages(sessionId) {
+        const state = this.getSessionState(sessionId);
+        if (state.initialized)
+            return null;
+        const id1 = state.rpcIdCounter++;
+        const id2 = state.rpcIdCounter++;
+        state.pendingRequests.set(id1, "initialize");
+        state.pendingRequests.set(id2, "thread/start");
+        state.initialized = true;
+        const threadStartParams = this.buildThreadStartParams(state.permissionMode);
+        return [
+            JSON.stringify({ jsonrpc: "2.0", id: id1, method: "initialize", params: { clientInfo: { name: "vibedeckx", version: "1.0.0" } } }),
+            JSON.stringify({ jsonrpc: "2.0", id: id2, method: "thread/start", params: threadStartParams }),
+        ].join("\n") + "\n";
+    }
+    // ============ Task 5.10: formatUserInput — JSON-RPC message construction ============
+    formatUserInput(content, sessionId) {
+        const state = this.getSessionState(sessionId);
+        // Sync permissionMode from last buildSpawnConfig call
+        state.permissionMode = this.lastPermissionMode;
+        // Fast path: threadId already available (pre-initialization completed)
+        if (state.threadId) {
+            const id = state.rpcIdCounter++;
+            state.pendingRequests.set(id, "turn/start");
+            return JSON.stringify({
+                jsonrpc: "2.0",
+                id,
+                method: "turn/start",
+                params: { threadId: state.threadId, input: this.buildCodexInput(content) },
+            }) + "\n";
+        }
+        // Edge case: getInitializationMessages wasn't called (e.g. dormant session wake)
+        if (!state.initialized) {
+            const id1 = state.rpcIdCounter++;
+            const id2 = state.rpcIdCounter++;
+            state.pendingRequests.set(id1, "initialize");
+            state.pendingRequests.set(id2, "thread/start");
+            state.initialized = true;
+            state.pendingTurnContent = content;
+            const threadStartParams = this.buildThreadStartParams(state.permissionMode);
+            return [
+                JSON.stringify({ jsonrpc: "2.0", id: id1, method: "initialize", params: { clientInfo: { name: "vibedeckx", version: "1.0.0" } } }),
+                JSON.stringify({ jsonrpc: "2.0", id: id2, method: "thread/start", params: threadStartParams }),
+            ].join("\n") + "\n";
+        }
+        // Initialized but threadId not yet available (race: user sent message before thread/start responded)
+        // Buffer content — will be sent when parseStdoutLine receives thread/start response
+        state.pendingTurnContent = content;
+        return "";
+    }
+    // ============ Task 5.12: Permission mode mapping ============
+    /** Build params for thread/start — uses `sandbox` (string enum) per ThreadStartParams schema */
+    buildThreadStartParams(mode) {
+        if (mode === "plan") {
+            return {
+                sandbox: "read-only",
+            };
+        }
+        // edit mode
+        return {
+            sandbox: "workspace-write",
+            approvalPolicy: "on-request",
+        };
+    }
+    // ============ Task 5.11: formatApprovalResponse ============
+    formatApprovalResponse(requestId, decision, _sessionId) {
+        return JSON.stringify({
+            jsonrpc: "2.0",
+            id: Number(requestId),
+            result: { decision },
+        }) + "\n";
+    }
+    // ============ Interrupt (cancel current turn) ============
+    formatInterrupt(sessionId) {
+        const state = this.getSessionState(sessionId);
+        for (const [id, method] of state.pendingRequests) {
+            if (method === "turn/start") {
+                return JSON.stringify({
+                    jsonrpc: "2.0",
+                    method: "$/cancelRequest",
+                    params: { id },
+                }) + "\n";
+            }
+        }
+        return null;
+    }
+    // ============ Lifecycle hooks ============
+    onSessionCreated(sessionId) {
+        this.sessions.set(sessionId, {
+            threadId: null,
+            rpcIdCounter: 1,
+            initialized: false,
+            pendingRequests: new Map(),
+            permissionMode: "edit",
+            pendingTurnContent: null,
+        });
+    }
+    onSessionDestroyed(sessionId) {
+        this.sessions.delete(sessionId);
+    }
+    /** Get session state, creating default if missing (defensive). */
+    getSessionState(sessionId) {
+        let state = this.sessions.get(sessionId);
+        if (!state) {
+            state = {
+                threadId: null,
+                rpcIdCounter: 1,
+                initialized: false,
+                pendingRequests: new Map(),
+                permissionMode: "edit",
+                pendingTurnContent: null,
+            };
+            this.sessions.set(sessionId, state);
+        }
+        return state;
+    }
+    /** Build Codex input array from string or ContentPart[] */
+    buildCodexInput(content) {
+        if (typeof content === "string") {
+            return [{ type: "text", text: content }];
+        }
+        return content.map((part) => {
+            if (part.type === "text") {
+                return { type: "text", text: part.text };
+            }
+            return { type: "image", url: `data:${part.mediaType};base64,${part.data}` };
+        });
+    }
+    generateId() {
+        return `codex-${++CodexProvider.idCounter}`;
+    }
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,5 @@
+import type { AgentType } from "../agent-types.js";
+import type { AgentProvider } from "../agent-provider.js";
+export declare function registerProvider(provider: AgentProvider): void;
+export declare function getProvider(agentType: AgentType): AgentProvider;
+export declare function getAllProviders(): AgentProvider[];

package/dist/providers/index.js

@@ -0,0 +1,19 @@
+import { ClaudeCodeProvider } from "./claude-code-provider.js";
+import { CodexProvider } from "./codex-provider.js";
+const providers = new Map();
+// Register built-in providers at module scope
+registerProvider(new ClaudeCodeProvider());
+registerProvider(new CodexProvider());
+export function registerProvider(provider) {
+    providers.set(provider.getAgentType(), provider);
+}
+export function getProvider(agentType) {
+    const provider = providers.get(agentType);
+    if (!provider) {
+        throw new Error(`No provider registered for agent type: ${agentType}`);
+    }
+    return provider;
+}
+export function getAllProviders() {
+    return Array.from(providers.values());
+}

package/dist/remote-patch-cache.d.ts

@@ -0,0 +1,67 @@
+/**
+ * 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.
+ */
+import type WebSocket from "ws";
+export interface CacheEntry {
+    /** Raw serialized WS messages (JsonPatch, taskCompleted, error, etc.) */
+    messages: string[];
+    /** Count of JsonPatch messages only */
+    patchCount: number;
+    /** Whether the remote sent { finished: true } */
+    finished: boolean;
+    /** Persistent WebSocket connection to the remote server (null if not connected) */
+    remoteWs: WebSocket | null;
+    /** Set of frontend WebSocket connections subscribed to this session */
+    subscribers: Set<WebSocket>;
+    /** Whether a reconnection attempt is in progress / scheduled */
+    reconnecting: boolean;
+    /** Timer handle for the next reconnection attempt (null if none scheduled) */
+    reconnectTimer: ReturnType<typeof setTimeout> | null;
+    /** Current reconnection attempt count (reset on successful stable connection) */
+    reconnectAttempt: number;
+}
+export declare class RemotePatchCache {
+    private cache;
+    getOrCreate(sessionId: string): CacheEntry;
+    get(sessionId: string): CacheEntry | undefined;
+    hasData(sessionId: string): boolean;
+    /**
+     * 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: string, raw: string, isJsonPatch: boolean): void;
+    /** Full cache replacement (used when cache is detected as stale). */
+    replaceAll(sessionId: string, messages: string[], patchCount: number): void;
+    setFinished(sessionId: string): void;
+    /** Store a persistent remote WebSocket connection. */
+    setRemoteWs(sessionId: string, ws: WebSocket | null): void;
+    /** Get the persistent remote WS if it exists and is open. */
+    getRemoteWs(sessionId: string): WebSocket | null;
+    /** Add a frontend WebSocket as a subscriber. */
+    addSubscriber(sessionId: string, frontendWs: WebSocket): void;
+    /** Remove a frontend WebSocket subscriber. */
+    removeSubscriber(sessionId: string, frontendWs: WebSocket): void;
+    setReconnecting(sessionId: string, value: boolean): void;
+    isReconnecting(sessionId: string): boolean;
+    setReconnectTimer(sessionId: string, timer: ReturnType<typeof setTimeout>): void;
+    clearReconnectTimer(sessionId: string): void;
+    getReconnectAttempt(sessionId: string): number;
+    incrementReconnectAttempt(sessionId: string): void;
+    resetReconnectAttempt(sessionId: string): void;
+    /** Broadcast a raw message to all subscribers, auto-removing dead ones. */
+    broadcast(sessionId: string, raw: string): void;
+    /**
+     * Close all remote WebSockets and clear all reconnect timers for graceful shutdown
+     */
+    shutdown(): void;
+    delete(sessionId: string): void;
+}