jarvis-hq 0.0.3

package/dist/server.js

@@ -0,0 +1,530 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequest = handleRequest;
+exports.start = start;
+const crypto_1 = require("crypto");
+const server_common_1 = require("./server-common");
+const start_claude_code_1 = require("./start-claude-code");
+const start_opencode_1 = require("./start-opencode");
+const start_codex_1 = require("./start-codex");
+const relay_client_1 = require("./relay-client");
+const bot_routes_1 = require("./bot-routes");
+const dictation_1 = require("./dictation");
+const bot_store_1 = require("./bot-store");
+const start_claude_code_2 = require("./start-claude-code");
+const turns_1 = require("./turns");
+const jarvis_1 = require("./jarvis");
+async function handleRequest(req, res, availableAgents, workspaceCwd) {
+    const url = req.url ?? "/";
+    const method = req.method ?? "GET";
+    const path = url.split("?")[0];
+    const query = (0, server_common_1.parseQuery)(url);
+    // CORS preflight
+    if (method === "OPTIONS") {
+        res.writeHead(204, {
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "GET, POST, PATCH, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type, Last-Event-ID, X-Client-Version, X-Daytona-Skip-Preview-Warning",
+        });
+        res.end();
+        return;
+    }
+    // SPA served by createHttpServer's listener — only handle API routes here
+    if (method === "GET" && (path === "/" || path === ""))
+        return;
+    try {
+        // Workspace + file system routes
+        if (await (0, server_common_1.handleWorkspaceRoutes)(req, res, workspaceCwd, availableAgents))
+            return;
+        // Bot hub: /bots and /threads
+        if (await (0, bot_routes_1.handleBotRoutes)(req, res, workspaceCwd))
+            return;
+        // Voice input: /dictate and /dictate/status
+        if (await (0, dictation_1.handleDictationRoutes)(req, res))
+            return;
+        // --- Jarvis ---
+        // GET /jarvis — the entry point: Jarvis's bot and the projects it knows.
+        if (method === "GET" && path === "/jarvis") {
+            const bot = (0, jarvis_1.ensureJarvisBot)();
+            (0, server_common_1.jsonOk)(res, { bot, dir: (0, jarvis_1.jarvisDir)(), projects: (0, jarvis_1.listProjects)() });
+            return;
+        }
+        // POST /jarvis/ask — a fresh Jarvis conversation from the home screen: opens
+        // a thread and sends the first message in one round trip.
+        if (method === "POST" && path === "/jarvis/ask") {
+            const body = await (0, server_common_1.readBody)(req);
+            const prompt = typeof body.prompt === "string" ? body.prompt.trim() : "";
+            if (!prompt) {
+                (0, server_common_1.jsonError)(res, 400, "prompt is required");
+                return;
+            }
+            if (!availableAgents.includes("claude-code")) {
+                (0, server_common_1.jsonError)(res, 400, "Agent 'claude-code' is not available");
+                return;
+            }
+            const bot = (0, jarvis_1.ensureJarvisBot)();
+            const thread = (0, bot_store_1.createThread)(bot.id, bot.repoPath ?? (0, jarvis_1.jarvisDir)());
+            const { store } = (0, turns_1.beginThreadTurn)(thread, bot, { prompt });
+            (0, server_common_1.jsonOk)(res, { thread: (0, bot_store_1.getThread)(thread.id) ?? thread, sessionId: store.gitbotId });
+            return;
+        }
+        // GET /sessions/active — threads with a turn in flight, so a client that
+        // was closed while work ran can rejoin it.
+        if (method === "GET" && path === "/sessions/active") {
+            (0, server_common_1.jsonOk)(res, { active: (0, turns_1.activeTurns)() });
+            return;
+        }
+        // GET /sessions
+        if (method === "GET" && path === "/sessions") {
+            const repoPath = query.repoPath ?? workspaceCwd;
+            const agent = query.agent;
+            if (!agent || agent === "claude-code") {
+                const list = await (0, start_claude_code_1.listSessions)(repoPath);
+                (0, server_common_1.jsonOk)(res, { sessions: list });
+                return;
+            }
+            if (agent === "opencode") {
+                const list = await (0, start_opencode_1.listSessions)(repoPath);
+                (0, server_common_1.jsonOk)(res, { sessions: list });
+                return;
+            }
+            if (agent === "codex") {
+                const list = await (0, start_codex_1.listSessions)(repoPath);
+                (0, server_common_1.jsonOk)(res, { sessions: list });
+                return;
+            }
+            (0, server_common_1.jsonOk)(res, { sessions: [] });
+            return;
+        }
+        // GET /sessions/:id/history
+        const historyId = (0, server_common_1.parsePathParam)(path, "/sessions/")?.replace(/\/history$/, "");
+        if (method === "GET" && path.endsWith("/history") && historyId) {
+            const store = server_common_1.sessions.get(historyId);
+            if (!store) {
+                const agentParam = query.agent;
+                if (agentParam === "opencode") {
+                    const history = await (0, start_opencode_1.getSessionHistory)(historyId, query.repoPath ?? workspaceCwd);
+                    (0, server_common_1.jsonOk)(res, { messages: history });
+                }
+                else if (agentParam === "codex") {
+                    const repoPath = query.repoPath ?? workspaceCwd;
+                    const history = await (0, start_codex_1.loadTranscript)(historyId, repoPath);
+                    (0, server_common_1.jsonOk)(res, { messages: history });
+                }
+                else {
+                    const repoPath = query.repoPath ?? workspaceCwd;
+                    const history = await (0, start_claude_code_1.loadTranscript)(historyId, repoPath);
+                    (0, server_common_1.jsonOk)(res, { messages: history });
+                }
+                return;
+            }
+            if (store.agent === "opencode" && store.sdkSessionId) {
+                const history = await (0, start_opencode_1.getSessionHistory)(store.sdkSessionId, store.repoPath);
+                (0, server_common_1.jsonOk)(res, { messages: history });
+            }
+            else if (store.agent === "codex") {
+                if (!store.sdkSessionId) {
+                    (0, server_common_1.jsonOk)(res, { messages: [] });
+                    return;
+                }
+                const history = await (0, start_codex_1.loadTranscript)(store.sdkSessionId, store.repoPath);
+                (0, server_common_1.jsonOk)(res, { messages: history });
+            }
+            else {
+                const history = await (0, start_claude_code_1.loadTranscript)(store.sdkSessionId ?? historyId, store.repoPath);
+                (0, server_common_1.jsonOk)(res, { messages: history });
+            }
+            return;
+        }
+        // GET /sessions/:id/config
+        const configId = (0, server_common_1.parsePathParam)(path, "/sessions/")?.replace(/\/config$/, "");
+        if (method === "GET" && path.endsWith("/config") && configId) {
+            const store = server_common_1.sessions.get(configId)
+                ?? [...server_common_1.sessions.values()].find(s => s.sdkSessionId === configId);
+            if (!store) {
+                (0, server_common_1.jsonError)(res, 404, "Session not found");
+                return;
+            }
+            (0, server_common_1.jsonOk)(res, {
+                gitbotId: store.gitbotId,
+                sessionId: store.sdkSessionId,
+                agent: store.agent,
+                model: store.model ?? null,
+                mode: store.mode ?? null,
+                permissionMode: store.permissionMode,
+            });
+            return;
+        }
+        // GET /sessions/:id/status
+        const statusId = (0, server_common_1.parsePathParam)(path, "/sessions/")?.replace(/\/status$/, "");
+        if (method === "GET" && path.endsWith("/status") && statusId) {
+            const store = server_common_1.sessions.get(statusId)
+                ?? [...server_common_1.sessions.values()].find(s => s.sdkSessionId === statusId);
+            if (!store) {
+                (0, server_common_1.jsonError)(res, 404, "Session not found");
+                return;
+            }
+            (0, server_common_1.jsonOk)(res, { streaming: store.status === "running", sdkSessionId: store.sdkSessionId ?? null });
+            return;
+        }
+        // GET /sessions/:id/permissions — which tool requests are still awaiting an
+        // answer. A client rejoining a running turn replays events it has already
+        // seen, and must not re-offer approvals that were resolved while it was away.
+        const permsId = (0, server_common_1.parsePathParam)(path, "/sessions/")?.replace(/\/permissions$/, "");
+        if (method === "GET" && path.endsWith("/permissions") && permsId) {
+            const store = server_common_1.sessions.get(permsId)
+                ?? [...server_common_1.sessions.values()].find(s => s.sdkSessionId === permsId);
+            if (!store) {
+                (0, server_common_1.jsonError)(res, 404, "Session not found");
+                return;
+            }
+            (0, server_common_1.jsonOk)(res, { pending: [...store.pendingPermissions.keys()] });
+            return;
+        }
+        // POST /sessions/:id/abort
+        const abortId = (0, server_common_1.parsePathParam)(path, "/sessions/")?.replace(/\/abort$/, "");
+        if (method === "POST" && path.endsWith("/abort") && abortId) {
+            const store = server_common_1.sessions.get(abortId)
+                ?? [...server_common_1.sessions.values()].find(s => s.sdkSessionId === abortId);
+            if (!store) {
+                (0, server_common_1.jsonError)(res, 404, "Session not found");
+                return;
+            }
+            if (store.status !== "running") {
+                (0, server_common_1.jsonOk)(res, { ok: true });
+                return;
+            }
+            if (store.agent === "claude-code" && store.abortController) {
+                store.abortController.abort();
+            }
+            else if (store.agent === "codex" && store.abortController) {
+                store.abortController.abort();
+            }
+            else if (store.agent === "opencode" && store.sdkSessionId) {
+                await (0, start_opencode_1.abortSession)(store.sdkSessionId, store.repoPath).catch(() => { });
+                store.status = "done";
+                store.pendingPermissions.clear();
+                (0, server_common_1.notifyPermissionsChanged)();
+                (0, server_common_1.emitEvent)(store, "aborted", { message: "Aborted by user" });
+                (0, server_common_1.scheduleCleanup)(store);
+            }
+            console.log(`[abort] session ${abortId}`);
+            (0, server_common_1.jsonOk)(res, { ok: true });
+            return;
+        }
+        // POST /sessions/:id/permission
+        const permBase = (0, server_common_1.parsePathParam)(path, "/sessions/")?.replace(/\/permission$/, "");
+        if (method === "POST" && path.endsWith("/permission") && permBase) {
+            const store = server_common_1.sessions.get(permBase);
+            if (!store) {
+                (0, server_common_1.jsonError)(res, 404, "Session not found");
+                return;
+            }
+            const body = await (0, server_common_1.readBody)(req);
+            const { toolUseID, approved, updatedInput } = body;
+            if (!toolUseID) {
+                (0, server_common_1.jsonError)(res, 400, "toolUseID is required");
+                return;
+            }
+            console.log(`[permission] id=${toolUseID} approved=${approved}`);
+            if (store.agent === "claude-code") {
+                const pending = store.pendingPermissions.get(toolUseID);
+                if (pending) {
+                    store.pendingPermissions.delete(toolUseID);
+                    (0, server_common_1.notifyPermissionsChanged)();
+                    pending.resolve(approved
+                        ? { behavior: "allow", updatedInput: updatedInput ?? pending.input }
+                        : { behavior: "deny", message: "User denied" });
+                }
+            }
+            else if (store.agent === "opencode" && store.sdkSessionId) {
+                const pending = store.pendingPermissions.get(toolUseID);
+                if (pending) {
+                    store.pendingPermissions.delete(toolUseID);
+                    (0, server_common_1.notifyPermissionsChanged)();
+                    // For subagent permissions, respond on the child sdkSessionId that actually raised the request.
+                    const respondSdkId = pending.askedBySdkSessionId ?? store.sdkSessionId;
+                    await (0, start_opencode_1.respondPermission)(respondSdkId, toolUseID, approved, store.repoPath).catch((err) => {
+                        console.error("Permission response failed:", err.message);
+                    });
+                }
+            }
+            (0, server_common_1.jsonOk)(res, { ok: true });
+            return;
+        }
+        // POST /chat
+        if (method === "POST" && path === "/chat") {
+            const body = await (0, server_common_1.readBody)(req);
+            const { repoPath, agent, sessionId: existingId, model, permissionMode, mode } = body;
+            const { prompt, attachments, threadId } = body;
+            // attachments: Array<{ url: string }> | undefined
+            // A threadId comes from the bot hub: the thread supplies the folder, the
+            // resume handle and the bot preset, so the client need not repeat them.
+            if (threadId) {
+                const thread = (0, bot_store_1.getThread)(threadId);
+                if (!thread) {
+                    (0, server_common_1.jsonError)(res, 404, "Thread not found");
+                    return;
+                }
+                const bot = (0, bot_store_1.getBot)(thread.botId);
+                if (!bot) {
+                    (0, server_common_1.jsonError)(res, 404, "Bot not found");
+                    return;
+                }
+                if (!availableAgents.includes("claude-code")) {
+                    (0, server_common_1.jsonError)(res, 400, "Agent 'claude-code' is not available");
+                    return;
+                }
+                if (!prompt && (!attachments || attachments.length === 0)) {
+                    (0, server_common_1.jsonError)(res, 400, "prompt or attachments is required");
+                    return;
+                }
+                // Work waits on setup; the setup thread itself is exempt, since it is
+                // the thing that clears the block.
+                if (thread.kind !== "setup" && (0, bot_store_1.botNeedsSetup)(bot)) {
+                    (0, server_common_1.jsonError)(res, 409, `${bot.name} still needs to set up this machine`, {
+                        setupRequired: true,
+                        setupThreadId: bot.setupThreadId,
+                    });
+                    return;
+                }
+                try {
+                    const { store } = (0, turns_1.beginThreadTurn)(thread, bot, {
+                        prompt: prompt ?? "",
+                        attachments,
+                        model,
+                        permissionMode: permissionMode,
+                        mode,
+                    });
+                    (0, server_common_1.jsonOk)(res, { sessionId: store.gitbotId });
+                }
+                catch (err) {
+                    if (err instanceof turns_1.TurnBusyError)
+                        (0, server_common_1.jsonError)(res, 409, err.message);
+                    else
+                        throw err;
+                }
+                return;
+            }
+            if (!repoPath) {
+                (0, server_common_1.jsonError)(res, 400, "repoPath is required");
+                return;
+            }
+            if (!prompt && (!attachments || attachments.length === 0)) {
+                (0, server_common_1.jsonError)(res, 400, "prompt or attachments is required");
+                return;
+            }
+            if (attachments != null && (!Array.isArray(attachments) || attachments.some((a) => typeof a?.url !== "string" || !a.url))) {
+                (0, server_common_1.jsonError)(res, 400, "attachments must be an array of { url: string }");
+                return;
+            }
+            if (agent !== "claude-code" && agent !== "opencode" && agent !== "codex") {
+                (0, server_common_1.jsonError)(res, 400, "agent must be claude-code, opencode, or codex");
+                return;
+            }
+            if (!availableAgents.includes(agent)) {
+                (0, server_common_1.jsonError)(res, 400, `Agent '${agent}' is not available`);
+                return;
+            }
+            let store = existingId ? server_common_1.sessions.get(existingId) : undefined;
+            if (store) {
+                if (store.status === "running") {
+                    (0, server_common_1.jsonError)(res, 409, "Session is already running");
+                    return;
+                }
+                store.status = "running";
+                (0, server_common_1.notifyPermissionsChanged)();
+                store.events = [];
+                store.seq = 0;
+                if (model)
+                    store.model = model;
+                if (mode)
+                    store.mode = mode;
+                if (permissionMode)
+                    store.permissionMode = permissionMode;
+                (0, server_common_1.emitEvent)(store, 'user_prompt', { prompt: prompt ?? '', ...(attachments?.length ? { attachments } : {}) });
+            }
+            else {
+                const gitbotId = existingId ?? (0, crypto_1.randomUUID)();
+                store = (0, server_common_1.createSession)(gitbotId, agent, repoPath, model, mode, permissionMode);
+                if (existingId) {
+                    store.sdkSessionId = existingId;
+                }
+                (0, server_common_1.emitEvent)(store, 'user_prompt', { prompt: prompt ?? '', ...(attachments?.length ? { attachments } : {}) });
+                (0, server_common_1.notifyPermissionsChanged)();
+            }
+            const s = store;
+            (0, server_common_1.notifySessionStarted)();
+            if (agent === "claude-code") {
+                (0, start_claude_code_1.runAgent)(s).catch((err) => {
+                    console.error("[runAgent] unhandled:", err);
+                }).finally(() => (0, server_common_1.notifySessionEnded)());
+            }
+            else if (agent === "codex") {
+                (0, start_codex_1.runAgent)(s).catch((err) => {
+                }).finally(() => (0, server_common_1.notifySessionEnded)());
+            }
+            else if (agent === "opencode") {
+                (0, start_opencode_1.runAgent)(s).catch((err) => {
+                    console.error("[runAgent] unhandled:", err);
+                }).finally(() => (0, server_common_1.notifySessionEnded)());
+            }
+            else {
+                (0, start_opencode_1.runAgent)(s).catch((err) => {
+                    console.error("[runAgent] unhandled:", err);
+                }).finally(() => (0, server_common_1.notifySessionEnded)());
+            }
+            (0, server_common_1.jsonOk)(res, { sessionId: s.gitbotId });
+            return;
+        }
+        // GET /events?sessionId=X
+        if (method === "GET" && path === "/events") {
+            const sessionId = query.sessionId;
+            if (!sessionId) {
+                (0, server_common_1.jsonError)(res, 400, "sessionId is required");
+                return;
+            }
+            const store = server_common_1.sessions.get(sessionId)
+                ?? [...server_common_1.sessions.values()].find(s => s.sdkSessionId === sessionId);
+            if (!store) {
+                (0, server_common_1.jsonError)(res, 404, "Session not found");
+                return;
+            }
+            const lastSeq = parseInt(req.headers["last-event-id"] ?? "0", 10) || 0;
+            res.writeHead(200, (0, server_common_1.sseHeaders)());
+            for (const event of store.events) {
+                if (event.seq > lastSeq) {
+                    (0, server_common_1.writeSseEvent)(res, event);
+                }
+            }
+            if (store.status !== "running") {
+                res.end();
+                return;
+            }
+            const listener = (event) => {
+                (0, server_common_1.writeSseEvent)(res, event);
+                if (event.type === "done" || event.type === "error" || event.type === "aborted") {
+                    res.end();
+                }
+            };
+            store.emitter.on("event", listener);
+            req.on("close", () => {
+                store.emitter.off("event", listener);
+            });
+            return;
+        }
+        // GET /permissions/events
+        if (method === "GET" && path === "/permissions/events") {
+            res.writeHead(200, (0, server_common_1.sseHeaders)());
+            const sendDump = (permissions, sessions) => {
+                if (res.writableEnded)
+                    return;
+                res.write(`event: permissions\ndata: ${JSON.stringify({ permissions, sessions })}\n\n`);
+            };
+            sendDump((0, server_common_1.buildPermissionsDump)(), (0, server_common_1.buildSessionsDump)());
+            server_common_1.permissionsEmitter.on("update", sendDump);
+            req.on("close", () => {
+                server_common_1.permissionsEmitter.off("update", sendDump);
+            });
+            return;
+        }
+        // PATCH /sessions/:id — update session settings mid-run
+        if (method === "PATCH" && path.startsWith("/sessions/")) {
+            const sessionId = path.slice("/sessions/".length);
+            const store = server_common_1.sessions.get(sessionId);
+            if (!store) {
+                (0, server_common_1.jsonError)(res, 404, "Session not found");
+                return;
+            }
+            const body = await (0, server_common_1.readBody)(req);
+            if (body.permissionMode !== undefined) {
+                const valid = ["ask-permissions", "allow-all-edits", "yolo"];
+                if (!valid.includes(body.permissionMode)) {
+                    (0, server_common_1.jsonError)(res, 400, "Invalid permissionMode");
+                    return;
+                }
+                store.permissionMode = body.permissionMode;
+                if (store.agent === "claude-code") {
+                    for (const [id, perm] of store.pendingPermissions) {
+                        if ((0, server_common_1.shouldAutoApprove)(store.agent, perm.toolName, store.permissionMode)) {
+                            store.pendingPermissions.delete(id);
+                            perm.resolve({ behavior: "allow", updatedInput: perm.input });
+                        }
+                    }
+                    (0, server_common_1.notifyPermissionsChanged)();
+                }
+                else if (store.agent === "codex") {
+                    // codex applies approvalPolicy at thread start — mode change takes effect next turn
+                }
+                else if (store.agent === "opencode" && store.sdkSessionId) {
+                    for (const [id, perm] of store.pendingPermissions) {
+                        if ((0, server_common_1.shouldAutoApprove)(store.agent, perm.toolName, store.permissionMode)) {
+                            store.pendingPermissions.delete(id);
+                            const respondSdkId = perm.askedBySdkSessionId ?? store.sdkSessionId;
+                            await (0, start_opencode_1.respondPermission)(respondSdkId, id, true, store.repoPath).catch(() => { });
+                        }
+                    }
+                    (0, server_common_1.notifyPermissionsChanged)();
+                }
+            }
+            (0, server_common_1.jsonOk)(res, { sessionId: store.gitbotId, permissionMode: store.permissionMode });
+            return;
+        }
+        (0, server_common_1.jsonError)(res, 404, "Not found");
+    }
+    catch (err) {
+        console.error("[request] unhandled error:", err.message);
+        if (!res.headersSent) {
+            (0, server_common_1.jsonError)(res, 500, "Internal server error");
+        }
+    }
+}
+async function start(network = "local", portOverride, caffeinate = false, relayUrl) {
+    const workspaceCwd = process.cwd();
+    console.log(`jarvis — starting in ${workspaceCwd}`);
+    // Claude Code refuses to spawn inside another Claude Code session, which would
+    // otherwise surface only as an opaque "exited with code 1" on the first message.
+    if (process.env.CLAUDECODE) {
+        console.warn(`  warning: CLAUDECODE is set — this shell is inside a Claude Code session.`);
+        console.warn(`  The claude-code agent will refuse to start. Run jarvis from a plain terminal,`);
+        console.warn(`  or launch it with: env -u CLAUDECODE jarvis start -p <port>`);
+    }
+    (0, start_claude_code_2.setWorkspaceCwd)(workspaceCwd);
+    // Jarvis's world exists before anyone speaks to it: its directory, its bot,
+    // and a bot per known project.
+    try {
+        const jarvis = (0, jarvis_1.ensureJarvisBot)();
+        (0, jarvis_1.syncProjectBots)();
+        console.log(`  jarvis: ${(0, jarvis_1.jarvisDir)()} (${(0, jarvis_1.listProjects)().length} projects, bot ${jarvis.id.slice(0, 8)})`);
+    }
+    catch (err) {
+        console.warn(`  jarvis: could not initialise — ${err?.message ?? err}`);
+    }
+    const claudeAvailable = await (0, start_claude_code_1.initAgent)();
+    const opencodeAvailable = await (0, start_opencode_1.initAgent)();
+    const codexAvailable = await (0, start_codex_1.initAgent)();
+    const availableAgents = [
+        ...(claudeAvailable ? ["claude-code"] : []),
+        ...(opencodeAvailable ? ["opencode"] : []),
+        ...(codexAvailable ? ["codex"] : []),
+    ];
+    console.log(`  available agents: ${availableAgents.join(", ") || "none"}`);
+    if (relayUrl) {
+        const caffeinatePid = (0, server_common_1.maybeCaffeinate)(caffeinate);
+        (0, server_common_1.setupShutdown)(() => { }, caffeinatePid);
+        await (0, relay_client_1.startRelayMode)(relayUrl, availableAgents, workspaceCwd);
+        return;
+    }
+    const { server, caffeinatePid } = await (0, server_common_1.createHttpServer)({
+        portOverride,
+        caffeinate,
+        network,
+        label: "jarvis server",
+    });
+    server.on("request", (req, res) => {
+        handleRequest(req, res, availableAgents, workspaceCwd);
+    });
+    (0, server_common_1.setupShutdown)(() => {
+        server.close(() => process.exit(0));
+    }, caffeinatePid);
+}