jarvis-hq 0.0.3

package/dist/start-claude-code.js

@@ -0,0 +1,557 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setWorkspaceCwd = setWorkspaceCwd;
+exports.initAgent = initAgent;
+exports.runAgent = runAgent;
+exports.continueAgent = continueAgent;
+exports.loadTranscript = loadTranscript;
+exports.listSessions = listSessions;
+const claude_agent_sdk_1 = require("@anthropic-ai/claude-agent-sdk");
+const fs_1 = require("fs");
+const child_process_1 = require("child_process");
+const promises_1 = require("fs/promises");
+const readline_1 = require("readline");
+const path_1 = require("path");
+const os_1 = require("os");
+const crypto_1 = require("crypto");
+const server_common_1 = require("./server-common");
+const bot_store_1 = require("./bot-store");
+const jarvis_tools_1 = require("./jarvis-tools");
+// Where Jarvis's project checkouts live; set once by the server at startup.
+let workspaceCwd = process.cwd();
+function setWorkspaceCwd(cwd) { workspaceCwd = cwd; }
+async function initAgent() {
+    try {
+        (0, child_process_1.execSync)("claude --version", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        console.warn("  claude CLI not found — claude-code agent unavailable");
+        return false;
+    }
+}
+async function runAgent(store) {
+    const abortController = new AbortController();
+    store.abortController = abortController;
+    // The SDK reports a failed spawn as a bare exit code; the child's stderr is
+    // where the actual reason lives, so keep the tail of it for the error event.
+    const stderrTail = [];
+    try {
+        let modelLogged = false;
+        const lastUserEvent = [...store.events].reverse().find(e => e.type === "user_prompt");
+        const promptText = lastUserEvent?.prompt ?? "";
+        const attachments = lastUserEvent?.attachments;
+        let promptParam;
+        if (attachments && attachments.length > 0) {
+            const content = [];
+            if (promptText)
+                content.push({ type: "text", text: promptText });
+            for (const att of attachments) {
+                content.push({ type: "image", source: { type: "url", url: att.url } });
+            }
+            const sessionId = store.sdkSessionId ?? (0, crypto_1.randomUUID)();
+            async function* multimodalPrompt() {
+                yield {
+                    type: "user",
+                    message: { role: "user", content },
+                    parent_tool_use_id: null,
+                    session_id: sessionId,
+                };
+            }
+            promptParam = multimodalPrompt();
+        }
+        else {
+            promptParam = promptText;
+        }
+        // A bot is a preset: its instructions ride on top of Claude Code's own system
+        // prompt, and its tool lists constrain the run.
+        const preset = store.botPreset;
+        const append = preset?.setup
+            ? setupSystemPrompt(preset)
+            : preset?.jarvis
+                ? preset.instructions
+                : preset?.instructions
+                    ? botSystemPrompt(preset)
+                    : undefined;
+        // Jarvis gets its dispatch tools in-process. A delegated task can run for
+        // many minutes, well past the SDK's default close timeout for tool calls.
+        const jarvis = preset?.jarvis
+            ? {
+                mcpServers: { [jarvis_tools_1.JARVIS_MCP_NAME]: (0, jarvis_tools_1.buildJarvisTools)(store, workspaceCwd) },
+                allowedTools: [...jarvis_tools_1.JARVIS_TOOL_NAMES, ...(preset.allowedTools ?? [])],
+                env: { ...process.env, CLAUDE_CODE_STREAM_CLOSE_TIMEOUT: String(6 * 60 * 60 * 1000) },
+            }
+            : {};
+        const q = (0, claude_agent_sdk_1.query)({
+            prompt: promptParam,
+            options: {
+                model: store.model ?? "claude-sonnet-4-6",
+                permissionMode: store.mode === "plan" ? "plan" : "default",
+                abortController,
+                includePartialMessages: true,
+                cwd: store.repoPath,
+                // The SDK loads no filesystem config by default. Opt in so the bot picks up
+                // .mcp.json servers (plus CLAUDE.md and permission settings) the way the CLI does.
+                settingSources: ["user", "project", "local"],
+                stderr: (data) => {
+                    stderrTail.push(data);
+                    if (stderrTail.length > 20)
+                        stderrTail.shift();
+                },
+                ...(append
+                    ? { systemPrompt: { type: "preset", preset: "claude_code", append } }
+                    : {}),
+                ...(preset?.allowedTools?.length ? { allowedTools: preset.allowedTools } : {}),
+                ...(preset?.disallowedTools?.length ? { disallowedTools: preset.disallowedTools } : {}),
+                ...jarvis,
+                ...(store.sdkSessionId ? { resume: store.sdkSessionId } : {}),
+                canUseTool: (toolName, input, { signal, toolUseID }) => {
+                    return new Promise((resolve) => {
+                        console.log(`[canUseTool] tool="${toolName}" mode="${store.permissionMode}" autoApprove=${(0, server_common_1.shouldAutoApprove)(store.agent, toolName, store.permissionMode)}`);
+                        if ((0, server_common_1.shouldAutoApprove)(store.agent, toolName, store.permissionMode)) {
+                            resolve({ behavior: "allow", updatedInput: input });
+                            return;
+                        }
+                        store.pendingPermissions.set(toolUseID, { resolve, input, toolName, toolUseID });
+                        (0, server_common_1.notifyNewPermission)(toolName);
+                        (0, server_common_1.emitEvent)(store, "permission_request", { toolUseID, toolName, input });
+                        signal.addEventListener("abort", () => {
+                            const p = store.pendingPermissions.get(toolUseID);
+                            if (p) {
+                                store.pendingPermissions.delete(toolUseID);
+                                (0, server_common_1.notifyPermissionsChanged)();
+                                p.resolve({ behavior: "deny", message: "Request aborted" });
+                            }
+                        }, { once: true });
+                    });
+                },
+            },
+        });
+        let receivedResult = false;
+        // A setup run says how it went in words; the marker is what the hub reads.
+        let assistantText = "";
+        try {
+            for await (const msg of q) {
+                if (msg.type === "system" && msg.subtype === "init") {
+                    const newSdkId = msg.session_id;
+                    if (newSdkId && !store.sdkSessionId) {
+                        store.sdkSessionId = newSdkId;
+                        // Bind the hub thread to its transcript the first time we learn the id.
+                        if (store.threadId)
+                            (0, bot_store_1.bindSession)(store.threadId, newSdkId);
+                    }
+                }
+                if (msg.type === "result")
+                    receivedResult = true;
+                if (!modelLogged && msg.type === "assistant" && msg.message?.model) {
+                    modelLogged = true;
+                }
+                if (preset?.setup && msg.type === "assistant") {
+                    for (const block of msg.message?.content ?? []) {
+                        if (block?.type === "text" && block.text)
+                            assistantText += block.text + "\n";
+                    }
+                }
+                const payload = formatMessage(msg);
+                if (payload) {
+                    const items = Array.isArray(payload) ? payload : [payload];
+                    for (const item of items) {
+                        (0, server_common_1.emitEvent)(store, item.type, item);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            if (err?.name === "AbortError" || abortController.signal.aborted) {
+                console.log("[query] aborted");
+                (0, server_common_1.emitEvent)(store, "aborted", { message: "Request aborted by user" });
+            }
+            else {
+                throw err;
+            }
+        }
+        if (preset?.setup)
+            recordSetupOutcome(preset.id, assistantText);
+        if (!receivedResult) {
+            console.log("[query] stream ended without result message — treating as error");
+            (0, server_common_1.emitEvent)(store, "error", { message: "Claude process exited unexpectedly" });
+            store.status = "error";
+            (0, server_common_1.scheduleCleanup)(store);
+            return;
+        }
+    }
+    catch (err) {
+        console.log("[query] outer error:", err?.message, err?.stack);
+        const detail = stderrTail.join("").trim();
+        (0, server_common_1.emitEvent)(store, "error", {
+            message: detail ? `${err?.message ?? "Agent failed"}\n\n${detail}` : (err?.message ?? "Unknown error"),
+        });
+        store.status = "error";
+        (0, server_common_1.scheduleCleanup)(store);
+        return;
+    }
+    finally {
+        store.abortController = null;
+        store.pendingPermissions.clear();
+        (0, server_common_1.notifyPermissionsChanged)();
+    }
+    store.status = "done";
+    (0, server_common_1.notifyPermissionsChanged)();
+    (0, server_common_1.emitEvent)(store, "done", {});
+    (0, server_common_1.notifySessionDone)(store);
+    (0, server_common_1.scheduleCleanup)(store);
+}
+// Re-entrant: called for subsequent prompts on the same session
+async function continueAgent(store, prompt) {
+    // Inject the prompt as a stored event for reference (not replayed to SDK)
+    // Then run agent — sdkSessionId already set so SDK will resume
+    store.events.push({ seq: 0, type: "user_prompt", prompt });
+    store.status = "running";
+    (0, server_common_1.notifyPermissionsChanged)();
+    await runAgent(store);
+}
+/**
+ * Frames a bot's instructions as a standing job. The instructions alone read as
+ * background colour, so a bare "hi" often gets a greeting back instead of the
+ * work; naming the job and saying when to start it makes the first turn reliable.
+ */
+function botSystemPrompt(preset) {
+    return [
+        `You are "${preset.name}", an agent with one standing job in this workspace.`,
+        "",
+        "YOUR JOB:",
+        preset.instructions.trim(),
+        "",
+        "Start this job on the user's first message of the conversation, whatever that",
+        "message says — a greeting such as \"hi\" is a signal to begin, not small talk.",
+        "Do not ask what to work on and do not wait for a restatement of the job; the",
+        "job above is the request. Afterwards, follow the user's messages as usual,",
+        "keeping the job's constraints in force for the rest of the conversation.",
+    ].join("\n");
+}
+/**
+ * Frames the one-time machine-preparation run. The bot's own job is context
+ * here, not the task: the task is making this computer able to do that job.
+ * The run stays an ordinary conversation afterwards, so the user can take over
+ * when a step needs a human — a password, a licence, a choice of package manager.
+ */
+function setupSystemPrompt(preset) {
+    return [
+        `You are setting up the machine for "${preset.name}", a bot that has just been`,
+        "installed here. This thread is the one-time setup run, not the bot's work.",
+        "",
+        ...(preset.instructions.trim()
+            ? ["THE JOB THIS MACHINE IS BEING PREPARED FOR (context only — do not do it now):",
+                preset.instructions.trim(), ""]
+            : []),
+        "SETUP INSTRUCTIONS FROM THE BOT'S AUTHOR:",
+        (preset.setupInstructions ?? "").trim(),
+        "",
+        "HOW TO RUN THIS:",
+        "Begin as soon as the user's first message arrives, whatever it says. Check what",
+        "is already present before installing anything — a machine that is ready needs no",
+        "changes. Prefer the platform's usual package manager, keep changes to what the",
+        "instructions call for, and explain anything that touches system state before you",
+        "do it. If a step needs the user — a password, a licence key, an account, a choice",
+        "you cannot make for them — ask in this thread and wait; this is a normal",
+        "conversation and they can answer.",
+        "",
+        "HOW TO FINISH:",
+        "When the machine can do the job, verify it (run the tool, check the version),",
+        "then end your final message with a line containing exactly:",
+        "SETUP_COMPLETE",
+        "If you cannot get there — a missing dependency you may not install, an",
+        "unsupported platform, a step the user must do elsewhere — end your final message",
+        "with a line of the form:",
+        "SETUP_FAILED: <one line saying what is blocked>",
+        "Write one of those two markers only when the run has actually reached that",
+        "point; never write them while a step is still outstanding, and never mention",
+        "them as an example. The user may keep talking to you afterwards, and a later",
+        "turn may end with a marker of its own once the situation changes.",
+    ].join("\n");
+}
+/**
+ * Reads the run's verdict off the end of the transcript. The last marker wins,
+ * so a later turn that fixes a failure can flip the bot to ready.
+ */
+function recordSetupOutcome(botId, text) {
+    const matches = text.match(/^\s*SETUP_(COMPLETE|FAILED)\b/gm);
+    if (!matches?.length)
+        return;
+    const done = /COMPLETE/.test(matches[matches.length - 1]);
+    (0, bot_store_1.setSetupStatus)(botId, done ? "complete" : "failed");
+}
+function formatMessage(msg) {
+    switch (msg.type) {
+        case "system":
+            return { type: "system", subtype: msg.subtype, data: msg };
+        case "assistant": {
+            const payloads = [];
+            // Walk the blocks in order so the client can paint text and tool calls
+            // where they actually happened; consecutive text blocks coalesce.
+            let text = "";
+            const flushText = () => {
+                if (text)
+                    payloads.push({ type: "assistant", content: text });
+                text = "";
+            };
+            for (const block of msg.message.content) {
+                if (block.type === "text") {
+                    text += block.text;
+                }
+                else if (block.type === "tool_use") {
+                    flushText();
+                    payloads.push({
+                        type: "tool_use",
+                        tool_name: block.name,
+                        tool_input: formatToolInput(block.name, block.input),
+                    });
+                }
+            }
+            flushText();
+            return payloads.length === 1 ? payloads[0] : payloads.length > 1 ? payloads : null;
+        }
+        case "stream_event": {
+            const event = msg.event;
+            if (event?.type === "content_block_start") {
+                if (event.content_block?.type === "thinking") {
+                    return { type: "status", status: "thinking" };
+                }
+                if (event.content_block?.type === "tool_use") {
+                    return { type: "status", status: "tool", tool_name: event.content_block.name };
+                }
+            }
+            return null;
+        }
+        case "tool_progress": {
+            const tp = msg;
+            return { type: "status", status: "tool", tool_name: tp.tool_name, elapsed: tp.elapsed_time_seconds };
+        }
+        case "tool_use_summary": {
+            const ts = msg;
+            return { type: "status", status: "tool_summary", summary: ts.summary };
+        }
+        case "result":
+            if (msg.subtype === "success") {
+                return {
+                    type: "result",
+                    subtype: "success",
+                    result: msg.result,
+                    cost: msg.total_cost_usd,
+                    duration_ms: msg.duration_ms,
+                    num_turns: msg.num_turns,
+                };
+            }
+            return {
+                type: "result",
+                subtype: msg.subtype,
+                errors: "errors" in msg ? msg.errors : undefined,
+                cost: msg.total_cost_usd,
+                duration_ms: msg.duration_ms,
+            };
+        default:
+            return null;
+    }
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((b) => b.type === "text")
+            .map((b) => b.text)
+            .join("");
+    }
+    return "";
+}
+async function loadTranscript(sessionId, cwd) {
+    const encodedCwd = cwd.replace(/[/\\_]/g, "-");
+    const transcriptPath = (0, path_1.join)((0, os_1.homedir)(), ".claude", "projects", encodedCwd, `${sessionId}.jsonl`);
+    if (!(0, fs_1.existsSync)(transcriptPath))
+        return [];
+    const messages = [];
+    try {
+        const rl = (0, readline_1.createInterface)({
+            input: (0, fs_1.createReadStream)(transcriptPath, { encoding: "utf-8" }),
+            crlfDelay: Infinity,
+        });
+        for await (const line of rl) {
+            if (!line)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (entry.type === "user" && entry.userType === "external" && !entry.isMeta) {
+                const rawContent = entry.message?.content;
+                const blocks = [];
+                if (typeof rawContent === "string") {
+                    if (rawContent)
+                        blocks.push({ type: "text", text: rawContent });
+                }
+                else if (Array.isArray(rawContent)) {
+                    for (const b of rawContent) {
+                        if (b.type === "text" && b.text)
+                            blocks.push({ type: "text", text: b.text });
+                        else if (b.type === "image" && b.source?.url)
+                            blocks.push({ type: "image_url", url: b.source.url });
+                    }
+                }
+                if (blocks.length)
+                    messages.push({ role: "user", content: blocks });
+            }
+            if (entry.type === "assistant") {
+                const rawContent = entry.message?.content;
+                const blocks = [];
+                if (Array.isArray(rawContent)) {
+                    for (const b of rawContent) {
+                        if (b.type === "text" && b.text)
+                            blocks.push({ type: "text", text: b.text });
+                        else if (b.type === "tool_use") {
+                            let tool_input;
+                            try {
+                                tool_input = formatToolInput(b.name, b.input);
+                            }
+                            catch {
+                                tool_input = JSON.stringify(b.input) ?? "";
+                            }
+                            blocks.push({ type: "tool_use", tool_name: b.name, tool_input });
+                        }
+                    }
+                }
+                if (blocks.length)
+                    messages.push({ role: "assistant", content: blocks });
+            }
+            if (entry.type === "result" && entry.subtype === "success" && typeof entry.result === "string" && entry.result.trim()) {
+                messages.push({ role: "assistant", content: [{ type: "text", text: entry.result }] });
+            }
+        }
+        return messages;
+    }
+    catch (err) {
+        console.error("Error reading transcript:", err.message);
+        return [];
+    }
+}
+async function getSessionPreview(filePath) {
+    try {
+        try {
+            const line = (0, child_process_1.execFileSync)("grep", ["-m1", '"custom-title"', filePath], { encoding: "utf-8" }).trim();
+            const entry = JSON.parse(line);
+            if (entry.type === "custom-title" && typeof entry.customTitle === "string" && entry.customTitle.trim()) {
+                return entry.customTitle.trim();
+            }
+        }
+        catch {
+            // no custom-title entry found, fall through to preview
+        }
+        const rl = (0, readline_1.createInterface)({
+            input: (0, fs_1.createReadStream)(filePath, { encoding: "utf-8" }),
+            crlfDelay: Infinity,
+        });
+        const parts = [];
+        let totalLen = 0;
+        for await (const line of rl) {
+            if (!line)
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if ((entry.type === "user" && entry.userType === "external" && !entry.isMeta) ||
+                entry.type === "assistant") {
+                const raw = extractText(entry.message?.content).trim();
+                const text = raw.replace(/<[^>]*>/g, "").trim();
+                if (!text)
+                    continue;
+                parts.push(text);
+                totalLen += (parts.length > 1 ? 3 : 0) + text.length;
+                if (totalLen >= 80) {
+                    rl.close();
+                    break;
+                }
+            }
+        }
+        const preview = parts.join(" — ");
+        return preview.length > 80 ? preview.slice(0, 80) + "..." : preview;
+    }
+    catch {
+        return "";
+    }
+}
+async function listSessions(cwd) {
+    const encodedCwd = cwd.replace(/[/\\_]/g, "-");
+    const projectDir = (0, path_1.join)((0, os_1.homedir)(), ".claude", "projects", encodedCwd);
+    if (!(0, fs_1.existsSync)(projectDir))
+        return [];
+    try {
+        const files = await (0, promises_1.readdir)(projectDir);
+        const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+        const sessionList = await Promise.all(jsonlFiles.map(async (f) => {
+            const filePath = (0, path_1.join)(projectDir, f);
+            const id = f.replace(/\.jsonl$/, "");
+            const [preview, fileStat] = await Promise.all([
+                getSessionPreview(filePath),
+                (0, promises_1.stat)(filePath),
+            ]);
+            return { id, preview, updatedAt: fileStat.mtime.toISOString() };
+        }));
+        sessionList.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        return sessionList;
+    }
+    catch (err) {
+        console.error("Error listing sessions:", err.message);
+        return [];
+    }
+}
+function formatToolInput(toolName, input) {
+    switch (toolName) {
+        case "Bash":
+            return input.description
+                ? `${input.description}: ${input.command}`
+                : `${input.command}`;
+        case "Read":
+            return `${input.file_path}`;
+        case "Write":
+            return `${input.file_path} (${typeof input.content === "string" ? input.content.length : "?"} chars)`;
+        case "Edit":
+            return `${input.file_path}`;
+        case "Glob":
+            return input.path ? `${input.pattern} in ${input.path}` : `${input.pattern}`;
+        case "Grep":
+            return input.path ? `/${input.pattern}/ in ${input.path}` : `/${input.pattern}/`;
+        case "Task":
+            return `[${input.subagent_type}] ${input.description}`;
+        case "WebFetch":
+            return `${input.url}`;
+        case "WebSearch":
+            return `"${input.query}"`;
+        case "NotebookEdit":
+            return `${input.notebook_path} (${input.edit_mode || "replace"})`;
+        case "TodoWrite": {
+            const todos = input.todos;
+            if (!Array.isArray(todos))
+                return JSON.stringify(input);
+            return todos.map((t) => `[${t.status}] ${t.content}`).join(", ");
+        }
+        case "mcp__jarvis__delegate":
+            return `${input.project}: ${input.task}`;
+        case "mcp__jarvis__handoff":
+            return `${input.project}: ${input.message}`;
+        case "mcp__jarvis__read_project":
+        case "mcp__jarvis__update_project":
+            return `${input.project}`;
+        case "mcp__jarvis__create_project":
+            return `${input.name}${input.repo ? ` from ${input.repo}` : input.path ? ` at ${input.path}` : ""}`;
+        case "mcp__jarvis__list_projects":
+            return "";
+        default:
+            return JSON.stringify(input);
+    }
+}