@vibedeckx/linux-x64 0.1.10

package/dist/plugins/shared-services.js

@@ -0,0 +1,65 @@
+import fp from "fastify-plugin";
+import { ProcessManager } from "../process-manager.js";
+import { AgentSessionManager } from "../agent-session-manager.js";
+import { ChatSessionManager } from "../chat-session-manager.js";
+import { EventBus } from "../event-bus.js";
+import { ProxyManager } from "../utils/proxy-manager.js";
+import { setGlobalProxyManager } from "../utils/remote-proxy.js";
+import { RemotePatchCache } from "../remote-patch-cache.js";
+import { ReverseConnectManager } from "../reverse-connect-manager.js";
+import { BrowserManager } from "../browser-manager.js";
+import "../server-types.js";
+const sharedServices = async (fastify, opts) => {
+    const processManager = new ProcessManager(opts.storage);
+    const agentSessionManager = new AgentSessionManager(opts.storage);
+    agentSessionManager.restoreSessionsFromDb();
+    const remoteExecutorMap = new Map();
+    const remoteSessionMap = new Map();
+    const remotePatchCache = new RemotePatchCache();
+    const eventBus = new EventBus();
+    // Initialize proxy manager from stored settings
+    const proxyManager = new ProxyManager();
+    const savedProxy = opts.storage.settings.get("proxy");
+    if (savedProxy) {
+        try {
+            const config = JSON.parse(savedProxy);
+            proxyManager.updateConfig(config);
+            if (config.type !== "none") {
+                console.log(`[ProxyManager] Loaded ${config.type} proxy: ${config.host}:${config.port}`);
+            }
+        }
+        catch {
+            console.warn("[ProxyManager] Failed to parse saved proxy config, using direct connection");
+        }
+    }
+    setGlobalProxyManager(proxyManager);
+    const reverseConnectManager = new ReverseConnectManager();
+    const browserManager = new BrowserManager();
+    const chatSessionManager = new ChatSessionManager(opts.storage, processManager, agentSessionManager, remoteSessionMap, remoteExecutorMap, remotePatchCache, reverseConnectManager, browserManager);
+    reverseConnectManager.setStatusChangeHandler((remoteServerId, status) => {
+        opts.storage.remoteServers.updateStatus(remoteServerId, status);
+    });
+    fastify.decorate("storage", opts.storage);
+    fastify.decorate("processManager", processManager);
+    fastify.decorate("agentSessionManager", agentSessionManager);
+    fastify.decorate("chatSessionManager", chatSessionManager);
+    fastify.decorate("remoteExecutorMap", remoteExecutorMap);
+    fastify.decorate("remoteSessionMap", remoteSessionMap);
+    fastify.decorate("eventBus", eventBus);
+    fastify.decorate("proxyManager", proxyManager);
+    fastify.decorate("remotePatchCache", remotePatchCache);
+    fastify.decorate("reverseConnectManager", reverseConnectManager);
+    fastify.decorate("browserManager", browserManager);
+    agentSessionManager.setEventBus(eventBus);
+    chatSessionManager.setEventBus(eventBus);
+    processManager.setEventBus(eventBus);
+    // Graceful shutdown: kill child processes and clear timers when server closes
+    fastify.addHook("onClose", async () => {
+        agentSessionManager.shutdown();
+        processManager.shutdown();
+        remotePatchCache.shutdown();
+        reverseConnectManager.shutdown();
+        await browserManager.shutdown();
+    });
+};
+export default fp(sharedServices, { name: "shared-services" });

package/dist/process-manager.d.ts

@@ -0,0 +1,146 @@
+import type { Executor, Storage } from "./storage/types.js";
+import type { EventBus } from "./event-bus.js";
+export type LogMessage = {
+    type: "stdout";
+    data: string;
+} | {
+    type: "stderr";
+    data: string;
+} | {
+    type: "pty";
+    data: string;
+} | {
+    type: "finished";
+    exitCode: number;
+};
+export type InputMessage = {
+    type: "input";
+    data: string;
+} | {
+    type: "resize";
+    cols: number;
+    rows: number;
+};
+export interface TerminalInfo {
+    id: string;
+    projectId: string;
+    name: string;
+    cwd: string;
+    branch: string | null;
+}
+type LogSubscriber = (msg: LogMessage) => void;
+export declare class ProcessManager {
+    private processes;
+    private storage;
+    private eventBus;
+    private terminalCounter;
+    private binaryCache;
+    constructor(storage: Storage);
+    /**
+     * Detect a CLI binary by name, caching the result.
+     */
+    private detectBinary;
+    /**
+     * Build the shell command string for a prompt executor.
+     * Supports claude and codex providers.
+     */
+    private buildPromptCommand;
+    setEventBus(eventBus: EventBus): void;
+    /**
+     * Start a new process for the given executor
+     * Returns the process ID
+     * @param skipDb - When true, skip database operations (used for remote path-based execution
+     *                 where the executor doesn't exist in the local DB)
+     */
+    start(executor: Executor, projectPath: string, skipDb?: boolean): string;
+    /**
+     * Start an interactive terminal session (persistent shell, no command)
+     * Returns the process ID and name
+     */
+    startTerminal(projectId: string, cwd: string, branch?: string | null): {
+        id: string;
+        name: string;
+    };
+    /**
+     * Start a process using node-pty (for interactive commands)
+     */
+    private startPtyProcess;
+    /**
+     * Start a process using regular spawn (for non-interactive commands)
+     */
+    private startRegularProcess;
+    /**
+     * Start a Claude prompt executor using stream-json mode for real-time output.
+     * Spawns claude with --output-format=stream-json --input-format=stream-json,
+     * sends the prompt via stdin, and parses JSON output into formatted terminal text.
+     */
+    private startClaudeStreamProcess;
+    /**
+     * Stop a running process
+     */
+    stop(processId: string): boolean;
+    /**
+     * Kill a process group by sending SIGTERM to the negative PID
+     */
+    private killProcessGroup;
+    /**
+     * Try to stop a process by looking up its PID in the database (for orphaned processes after server restart)
+     */
+    private stopByPid;
+    /**
+     * Handle input from the client (for PTY processes)
+     */
+    handleInput(processId: string, message: InputMessage): boolean;
+    /**
+     * Send a command to a running terminal session (fire-and-forget).
+     * Writes the command + newline to the PTY. Does not wait for output.
+     */
+    sendToTerminal(processId: string, command: string): void;
+    /**
+     * Get recent output lines from a terminal's log buffer.
+     * Returns stripped ANSI text from the last N lines.
+     */
+    getRecentOutput(processId: string, maxLines?: number): string;
+    /**
+     * Check if a process is using PTY mode
+     */
+    isPtyProcess(processId: string): boolean;
+    /**
+     * Subscribe to log updates for a process
+     * Returns an unsubscribe function
+     */
+    subscribe(processId: string, callback: LogSubscriber): (() => void) | null;
+    /**
+     * Get all historical logs for a process
+     */
+    getLogs(processId: string): LogMessage[];
+    /**
+     * Check if a process is still running
+     */
+    isRunning(processId: string): boolean;
+    /**
+     * Get all running process IDs
+     */
+    getRunningProcessIds(): string[];
+    /**
+     * Get all running terminal sessions for a project
+     */
+    getTerminals(projectId: string, branch?: string | null): TerminalInfo[];
+    /**
+     * Get all processes for a given executor ID with their status and logs
+     */
+    getProcessesByExecutorId(executorId: string): Array<{
+        processId: string;
+        isRunning: boolean;
+        logs: LogMessage[];
+    }>;
+    /**
+     * Kill all running processes and clear state for graceful shutdown
+     */
+    shutdown(): void;
+    /**
+     * Broadcast a message to all subscribers of a process
+     */
+    private broadcast;
+}
+export {};