@vibedeckx/linux-x64 0.1.10

package/dist/agent-types.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Agent Session Types for Claude Code Integration
+ */
+export type AgentType = "claude-code" | "codex";
+export type TextPart = {
+    type: "text";
+    text: string;
+};
+export type ImagePart = {
+    type: "image";
+    mediaType: string;
+    data: string;
+};
+export type ContentPart = TextPart | ImagePart;
+export type AgentMessage = {
+    type: 'user';
+    content: string | ContentPart[];
+    timestamp: number;
+} | {
+    type: 'assistant';
+    content: string;
+    partial?: boolean;
+    timestamp: number;
+} | {
+    type: 'tool_use';
+    tool: string;
+    input: unknown;
+    toolUseId?: string;
+    timestamp: number;
+} | {
+    type: 'tool_result';
+    tool: string;
+    output: string;
+    toolUseId?: string;
+    timestamp: number;
+} | {
+    type: 'thinking';
+    content: string;
+    timestamp: number;
+} | {
+    type: 'error';
+    message: string;
+    timestamp: number;
+} | {
+    type: 'system';
+    content: string;
+    timestamp: number;
+} | {
+    type: 'approval_request';
+    requestType: 'command' | 'fileChange';
+    requestId: string;
+    command?: string;
+    cwd?: string;
+    changes?: Array<{
+        path: string;
+        diff?: string;
+        kind: string;
+    }>;
+    timestamp: number;
+};
+/**
+ * Messages from Claude Code stdout (stream-json format)
+ */
+export type ClaudeOutputMessage = ClaudeAssistantMessage | ClaudeUserMessage | ClaudeSystemMessage | ClaudeResultMessage | ClaudeUnknownMessage;
+export interface ClaudeAssistantMessage {
+    type: 'assistant';
+    message: {
+        id: string;
+        type: 'message';
+        role: 'assistant';
+        content: ClaudeContentBlock[];
+        model: string;
+        stop_reason: string | null;
+        stop_sequence: string | null;
+    };
+    session_id: string;
+}
+export interface ClaudeUserMessage {
+    type: 'user';
+    message: {
+        role: 'user';
+        content: string | ClaudeContentBlock[];
+    };
+    session_id: string;
+}
+export interface ClaudeSystemMessage {
+    type: 'system';
+    subtype: string;
+    message?: string;
+    session_id?: string;
+}
+export interface ClaudeResultMessage {
+    type: 'result';
+    subtype: 'success' | 'error';
+    duration_ms?: number;
+    duration_api_ms?: number;
+    cost_usd?: number;
+    session_id?: string;
+    error?: string;
+}
+export interface ClaudeUnknownMessage {
+    type: string;
+    [key: string]: unknown;
+}
+export type ClaudeContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string | unknown;
+} | {
+    type: 'thinking';
+    thinking: string;
+};
+export type ClaudeImageBlock = {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+};
+export interface ClaudeUserInput {
+    type: 'user';
+    message: {
+        role: 'user';
+        content: string | (ClaudeContentBlock | ClaudeImageBlock)[];
+    };
+}
+export type AgentSessionStatus = 'running' | 'stopped' | 'error';
+export interface AgentSession {
+    id: string;
+    project_id: string;
+    branch: string;
+    status: AgentSessionStatus;
+    created_at: string;
+}
+export type { AgentWsMessage, Patch, PatchEntry, PatchValue } from './conversation-patch.js';
+export interface AgentWsInput {
+    type: 'user_message';
+    content: string | ContentPart[];
+}

package/dist/agent-types.js

@@ -0,0 +1,4 @@
+/**
+ * Agent Session Types for Claude Code Integration
+ */
+export {};

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { run } from "@stricli/core";
+import { program } from "./command.js";
+run(program, process.argv.slice(2), { process });

package/dist/browser-manager.d.ts

@@ -0,0 +1,46 @@
+/**
+ * BrowserManager — manages server-side Playwright browser instances.
+ *
+ * One browser session per project. Provides page automation (navigate, click, fill)
+ * and captures errors via CDP event listeners. Errors are forwarded to a callback
+ * (wired to ChatSessionManager for [Browser Event] injection).
+ *
+ * Playwright is an optional dependency — loaded lazily on first use.
+ * If not installed, startSession() throws with install instructions.
+ */
+type Page = import("playwright-core").Page;
+export interface BrowserError {
+    type: "js_error" | "console_error" | "network_error" | "crash";
+    message: string;
+    source?: string;
+    stack?: string;
+    timestamp: number;
+    url?: string;
+    status?: number;
+}
+export interface BrowserSessionInfo {
+    id: string;
+    projectId: string;
+    branch: string | null;
+    url: string;
+    status: "starting" | "running" | "stopped";
+}
+export declare class BrowserManager {
+    private sessions;
+    /** projectId -> sessionId */
+    private projectIndex;
+    startSession(projectId: string, branch: string | null, errorCallback?: (error: BrowserError) => void): Promise<BrowserSessionInfo>;
+    stopSession(projectId: string): Promise<boolean>;
+    getSession(projectId: string): BrowserSessionInfo | null;
+    /** Get the raw Playwright Page for tool execution. Internal use only. */
+    getPage(projectId: string): Page | null;
+    navigate(projectId: string, url: string): Promise<{
+        title: string;
+        url: string;
+    } | null>;
+    shutdown(): Promise<void>;
+    private attachErrorListeners;
+    private reportError;
+    private toInfo;
+}
+export {};

package/dist/browser-manager.js

@@ -0,0 +1,182 @@
+/**
+ * BrowserManager — manages server-side Playwright browser instances.
+ *
+ * One browser session per project. Provides page automation (navigate, click, fill)
+ * and captures errors via CDP event listeners. Errors are forwarded to a callback
+ * (wired to ChatSessionManager for [Browser Event] injection).
+ *
+ * Playwright is an optional dependency — loaded lazily on first use.
+ * If not installed, startSession() throws with install instructions.
+ */
+const MAX_ERRORS = 100;
+// ============ Lazy Playwright loader ============
+let playwrightModule = null;
+async function getPlaywright() {
+    if (playwrightModule)
+        return playwrightModule;
+    try {
+        playwrightModule = await import("playwright-core");
+        return playwrightModule;
+    }
+    catch {
+        throw new Error("playwright-core is not installed. Install it with: pnpm add playwright-core && npx playwright install chromium");
+    }
+}
+// ============ Manager ============
+export class BrowserManager {
+    sessions = new Map();
+    /** projectId -> sessionId */
+    projectIndex = new Map();
+    async startSession(projectId, branch, errorCallback) {
+        // Return existing session if one exists
+        const existingId = this.projectIndex.get(projectId);
+        if (existingId) {
+            const existing = this.sessions.get(existingId);
+            if (existing && existing.status === "running") {
+                return this.toInfo(existing);
+            }
+        }
+        const pw = await getPlaywright();
+        const id = `browser-${projectId}-${Date.now()}`;
+        const browser = await pw.chromium.launch({
+            headless: true,
+            args: [
+                "--no-sandbox",
+                "--disable-gpu",
+                "--disable-dev-shm-usage",
+            ],
+        });
+        const context = await browser.newContext();
+        const page = await context.newPage();
+        const session = {
+            id,
+            projectId,
+            branch,
+            browser,
+            context,
+            page,
+            url: "",
+            status: "running",
+            errors: [],
+            errorCallback: errorCallback ?? null,
+        };
+        this.attachErrorListeners(session);
+        this.sessions.set(id, session);
+        this.projectIndex.set(projectId, id);
+        console.log(`[BrowserManager] Started session ${id} for project=${projectId}`);
+        return this.toInfo(session);
+    }
+    async stopSession(projectId) {
+        const sessionId = this.projectIndex.get(projectId);
+        if (!sessionId)
+            return false;
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        session.status = "stopped";
+        try {
+            await session.context.close();
+            await session.browser.close();
+        }
+        catch (err) {
+            console.error(`[BrowserManager] Error closing session ${sessionId}:`, err);
+        }
+        this.sessions.delete(sessionId);
+        this.projectIndex.delete(projectId);
+        console.log(`[BrowserManager] Stopped session ${sessionId}`);
+        return true;
+    }
+    getSession(projectId) {
+        const sessionId = this.projectIndex.get(projectId);
+        if (!sessionId)
+            return null;
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return null;
+        return this.toInfo(session);
+    }
+    /** Get the raw Playwright Page for tool execution. Internal use only. */
+    getPage(projectId) {
+        const sessionId = this.projectIndex.get(projectId);
+        if (!sessionId)
+            return null;
+        return this.sessions.get(sessionId)?.page ?? null;
+    }
+    async navigate(projectId, url) {
+        const sessionId = this.projectIndex.get(projectId);
+        if (!sessionId)
+            return null;
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return null;
+        try {
+            await session.page.goto(url, { waitUntil: "domcontentloaded", timeout: 30000 });
+            session.url = session.page.url();
+            const title = await session.page.title();
+            return { title, url: session.url };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : "Navigation failed";
+            throw new Error(message);
+        }
+    }
+    async shutdown() {
+        const projectIds = [...this.projectIndex.keys()];
+        for (const projectId of projectIds) {
+            await this.stopSession(projectId);
+        }
+        console.log("[BrowserManager] Shutdown complete");
+    }
+    // ---- Error capture ----
+    attachErrorListeners(session) {
+        const { page } = session;
+        page.on("pageerror", (error) => {
+            this.reportError(session, {
+                type: "js_error",
+                message: error.message,
+                stack: error.stack,
+                timestamp: Date.now(),
+            });
+        });
+        page.on("console", (msg) => {
+            if (msg.type() === "error") {
+                this.reportError(session, {
+                    type: "console_error",
+                    message: msg.text(),
+                    timestamp: Date.now(),
+                });
+            }
+        });
+        page.on("requestfailed", (request) => {
+            this.reportError(session, {
+                type: "network_error",
+                message: `${request.method()} ${request.url()} -- ${request.failure()?.errorText ?? "unknown"}`,
+                url: request.url(),
+                timestamp: Date.now(),
+            });
+        });
+        page.on("crash", () => {
+            this.reportError(session, {
+                type: "crash",
+                message: "Browser tab crashed",
+                timestamp: Date.now(),
+            });
+        });
+    }
+    reportError(session, error) {
+        session.errors.push(error);
+        if (session.errors.length > MAX_ERRORS) {
+            session.errors.shift();
+        }
+        session.errorCallback?.(error);
+    }
+    toInfo(session) {
+        return {
+            id: session.id,
+            projectId: session.projectId,
+            branch: session.branch,
+            url: session.url,
+            status: session.status,
+        };
+    }
+}

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

@@ -0,0 +1,101 @@
+/**
+ * ChatSessionManager — lightweight AI chat session manager using Vercel AI SDK.
+ *
+ * No child processes, no tool tracking, no permission modes.
+ * Streams responses from DeepSeek via `streamText` and broadcasts
+ * JSON Patches over WebSocket (same architecture as AgentSessionManager).
+ */
+import type WebSocket from "ws";
+import type { AgentMessage, AgentSessionStatus } from "./agent-types.js";
+import type { Patch, BrowserCommand, BrowserCommandResult } from "./conversation-patch.js";
+import type { Storage } from "./storage/types.js";
+import type { EventBus } from "./event-bus.js";
+import type { ProcessManager } from "./process-manager.js";
+import type { AgentSessionManager } from "./agent-session-manager.js";
+import type { RemoteExecutorInfo, RemoteSessionInfo } from "./server-types.js";
+import type { RemotePatchCache } from "./remote-patch-cache.js";
+import type { ReverseConnectManager } from "./reverse-connect-manager.js";
+import type { BrowserManager } from "./browser-manager.js";
+interface ChatStore {
+    patches: Patch[];
+    entries: AgentMessage[];
+    nextIndex: number;
+}
+interface ChatSession {
+    id: string;
+    projectId: string;
+    branch: string | null;
+    store: ChatStore;
+    subscribers: Set<WebSocket>;
+    status: AgentSessionStatus;
+    abortController: AbortController | null;
+    eventListeningEnabled: boolean;
+}
+export declare class ChatSessionManager {
+    /** sessionId → ChatSession */
+    private sessions;
+    /** projectId:branch → sessionId (one session per project+branch) */
+    private sessionIndex;
+    /** terminalId → watcher state for active terminal output watchers */
+    private terminalWatchers;
+    /** sessionId → queued messages waiting to be sent after current stream finishes */
+    private messageQueue;
+    private storage;
+    private eventBus;
+    private processManager;
+    private agentSessionManager;
+    private remoteSessionMap;
+    private remoteExecutorMap;
+    private remotePatchCache;
+    private reverseConnectManager;
+    private browserManager;
+    /** Pending browser commands waiting for iframe response: commandId → resolve */
+    private pendingBrowserCommands;
+    constructor(storage: Storage, processManager: ProcessManager, agentSessionManager: AgentSessionManager, remoteSessionMap: Map<string, RemoteSessionInfo>, remoteExecutorMap: Map<string, RemoteExecutorInfo>, remotePatchCache: RemotePatchCache, reverseConnectManager?: ReverseConnectManager, browserManager?: BrowserManager);
+    setEventBus(eventBus: EventBus): void;
+    setEventListening(sessionId: string, enabled: boolean): boolean;
+    getEventListening(sessionId: string): boolean;
+    private setupEventListeners;
+    private handleExecutorFinished;
+    private handleBrowserError;
+    private findRemoteSessionForProject;
+    /**
+     * Extract AgentMessage[] from the local remotePatchCache for a given session.
+     * Parses cached WS messages and collects ENTRY patch values into an ordered array.
+     */
+    private extractMessagesFromCache;
+    private summarizeMessages;
+    private startTerminalWatcher;
+    private stopTerminalWatcher;
+    /**
+     * Start a watcher for a remote terminal by opening a virtual channel over
+     * the existing reverse-connect WebSocket (or a direct WebSocket as fallback).
+     * Mirrors the local startTerminalWatcher() — accumulates output with
+     * debounce, flushes on "finished" or idle timeout, and feeds the result
+     * into enqueueOrSend().
+     */
+    private startRemoteTerminalWatcher;
+    getOrCreateSession(projectId: string, branch: string | null): string;
+    getSession(sessionId: string): ChatSession | null;
+    getMessages(sessionId: string): AgentMessage[];
+    subscribe(sessionId: string, ws: WebSocket): (() => void) | null;
+    private getSystemPrompt;
+    private createTools;
+    private enqueueOrSend;
+    private drainQueue;
+    sendMessage(sessionId: string, content: string): Promise<boolean>;
+    stopGeneration(sessionId: string): boolean;
+    private pushEntry;
+    private broadcastPatch;
+    /**
+     * Send a browser command to the frontend via WebSocket.
+     * The frontend forwards it to the iframe's injected script via postMessage.
+     * Returns the result or null if no subscribers or timeout.
+     */
+    sendBrowserCommand(sessionId: string, command: Omit<BrowserCommand, "id">, timeoutMs?: number): Promise<BrowserCommandResult | null>;
+    /**
+     * Called when the frontend sends a browserResult message back over WebSocket.
+     */
+    handleBrowserResult(result: BrowserCommandResult): void;
+}
+export {};