jarvis-hq 0.0.3

package/dist/bot-routes.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBotRoutes = handleBotRoutes;
+const server_common_1 = require("./server-common");
+const bot_store_1 = require("./bot-store");
+const fs_1 = require("fs");
+const start_claude_code_1 = require("./start-claude-code");
+/**
+ * REST surface for the bot hub: bots, their threads, and a thread's messages.
+ * Messages are not stored here — they are read back from Claude Code's own
+ * transcript using the thread's sdkSessionId.
+ *
+ * Returns true when the request was handled.
+ */
+async function handleBotRoutes(req, res, workspaceCwd) {
+    const url = req.url ?? "/";
+    const method = req.method ?? "GET";
+    const path = url.split("?")[0];
+    const query = (0, server_common_1.parseQuery)(url);
+    // --- Bots ---
+    if (path === "/bots") {
+        if (method === "GET") {
+            (0, server_common_1.jsonOk)(res, { bots: (0, bot_store_1.listBots)() });
+            return true;
+        }
+        if (method === "POST") {
+            const body = await (0, server_common_1.readBody)(req);
+            if (typeof body.name !== "string" || !body.name.trim()) {
+                (0, server_common_1.jsonError)(res, 400, "name is required");
+                return true;
+            }
+            const bot = (0, bot_store_1.createBot)({ ...body, name: body.name.trim() });
+            // A bot that states what it needs from a machine gets its setup thread the
+            // moment it lands here, whether it was made here or imported.
+            const setupThread = (0, bot_store_1.ensureSetupThread)(bot.id, workspaceCwd);
+            (0, server_common_1.jsonOk)(res, { bot: (0, bot_store_1.getBot)(bot.id) ?? bot, setupThread });
+            return true;
+        }
+    }
+    // POST /bots/:id/setup — the manual controls beside the automatic run.
+    const setupBotId = matchId(path, "/bots/", "/setup");
+    if (setupBotId && method === "POST") {
+        const bot = (0, bot_store_1.getBot)(setupBotId);
+        if (!bot) {
+            (0, server_common_1.jsonError)(res, 404, "Bot not found");
+            return true;
+        }
+        if (!bot.setupInstructions?.trim()) {
+            (0, server_common_1.jsonError)(res, 400, "This bot has no setup instructions");
+            return true;
+        }
+        const body = await (0, server_common_1.readBody)(req);
+        const action = body.action;
+        if (action !== "complete" && action !== "reset" && action !== "fail") {
+            (0, server_common_1.jsonError)(res, 400, "action must be complete, reset or fail");
+            return true;
+        }
+        // A reset re-arms the run and makes sure there is a thread to run it in —
+        // the old one may have been deleted.
+        const updated = (0, bot_store_1.setSetupStatus)(bot.id, action === "complete" ? "complete" : action === "fail" ? "failed" : "pending");
+        const setupThread = action === "reset" ? (0, bot_store_1.ensureSetupThread)(bot.id, workspaceCwd) : undefined;
+        (0, server_common_1.jsonOk)(res, { bot: (0, bot_store_1.getBot)(bot.id) ?? updated, setupThread });
+        return true;
+    }
+    const botId = matchId(path, "/bots/");
+    if (botId) {
+        if (method === "GET") {
+            const bot = (0, bot_store_1.getBot)(botId);
+            if (!bot) {
+                (0, server_common_1.jsonError)(res, 404, "Bot not found");
+                return true;
+            }
+            (0, server_common_1.jsonOk)(res, { bot });
+            return true;
+        }
+        if (method === "PATCH") {
+            const body = await (0, server_common_1.readBody)(req);
+            const bot = (0, bot_store_1.updateBot)(botId, body);
+            if (!bot) {
+                (0, server_common_1.jsonError)(res, 404, "Bot not found");
+                return true;
+            }
+            // Setup instructions can arrive on an edit, not just at creation.
+            const setupThread = (0, bot_store_1.ensureSetupThread)(bot.id, workspaceCwd);
+            (0, server_common_1.jsonOk)(res, { bot: (0, bot_store_1.getBot)(bot.id) ?? bot, setupThread });
+            return true;
+        }
+        if (method === "DELETE") {
+            if (!(0, bot_store_1.deleteBot)(botId)) {
+                (0, server_common_1.jsonError)(res, 404, "Bot not found");
+                return true;
+            }
+            (0, server_common_1.jsonOk)(res, { deleted: true });
+            return true;
+        }
+    }
+    // --- Threads ---
+    if (path === "/threads") {
+        if (method === "GET") {
+            (0, server_common_1.jsonOk)(res, { threads: (0, bot_store_1.listThreads)(query.botId) });
+            return true;
+        }
+        if (method === "POST") {
+            const body = await (0, server_common_1.readBody)(req);
+            const bot = body.botId ? (0, bot_store_1.getBot)(body.botId) : undefined;
+            if (!bot) {
+                (0, server_common_1.jsonError)(res, 400, "a valid botId is required");
+                return true;
+            }
+            // A thread runs where it is told to: the folder the user picked, else the
+            // bot's default, else the directory the CLI was started in.
+            const repoPath = body.repoPath ?? bot.repoPath ?? workspaceCwd;
+            if (!(0, fs_1.existsSync)(repoPath) || !(0, fs_1.statSync)(repoPath).isDirectory()) {
+                (0, server_common_1.jsonError)(res, 400, `Not a directory: ${repoPath}`);
+                return true;
+            }
+            // Setup comes first: a bot that has not prepared this machine cannot be
+            // given work yet. Its own setup thread is made by the server, never here.
+            if ((0, bot_store_1.botNeedsSetup)(bot)) {
+                const setupThread = (0, bot_store_1.ensureSetupThread)(bot.id, workspaceCwd);
+                (0, server_common_1.jsonError)(res, 409, `${bot.name} still needs to set up this machine`, {
+                    setupRequired: true,
+                    setupThreadId: setupThread?.id,
+                });
+                return true;
+            }
+            (0, server_common_1.jsonOk)(res, { thread: (0, bot_store_1.createThread)(bot.id, repoPath, body.title) });
+            return true;
+        }
+    }
+    // /threads/:id/messages must be matched before /threads/:id
+    const messagesId = matchId(path, "/threads/", "/messages");
+    if (messagesId && method === "GET") {
+        const thread = (0, bot_store_1.getThread)(messagesId);
+        if (!thread) {
+            (0, server_common_1.jsonError)(res, 404, "Thread not found");
+            return true;
+        }
+        // A thread that has not had a turn yet has no transcript on disk.
+        const messages = thread.sdkSessionId
+            ? await (0, start_claude_code_1.loadTranscript)(thread.sdkSessionId, thread.repoPath)
+            : [];
+        (0, server_common_1.jsonOk)(res, { messages });
+        return true;
+    }
+    const threadId = matchId(path, "/threads/");
+    if (threadId) {
+        if (method === "GET") {
+            const thread = (0, bot_store_1.getThread)(threadId);
+            if (!thread) {
+                (0, server_common_1.jsonError)(res, 404, "Thread not found");
+                return true;
+            }
+            (0, server_common_1.jsonOk)(res, { thread });
+            return true;
+        }
+        if (method === "PATCH") {
+            const body = await (0, server_common_1.readBody)(req);
+            const thread = (0, bot_store_1.updateThread)(threadId, body);
+            if (!thread) {
+                (0, server_common_1.jsonError)(res, 404, "Thread not found");
+                return true;
+            }
+            (0, server_common_1.jsonOk)(res, { thread });
+            return true;
+        }
+        if (method === "DELETE") {
+            const thread = (0, bot_store_1.getThread)(threadId);
+            if (!(0, bot_store_1.deleteThread)(threadId)) {
+                (0, server_common_1.jsonError)(res, 404, "Thread not found");
+                return true;
+            }
+            // Deleting the setup thread leaves the bot pointing at nothing; unbind so
+            // the next run can make a fresh one.
+            if (thread && thread.kind === "setup")
+                (0, bot_store_1.updateBot)(thread.botId, { setupThreadId: undefined });
+            (0, server_common_1.jsonOk)(res, { deleted: true });
+            return true;
+        }
+    }
+    return false;
+}
+/** Extracts a single path segment: matchId("/bots/abc", "/bots/") -> "abc". */
+function matchId(path, prefix, suffix = "") {
+    if (!path.startsWith(prefix))
+        return null;
+    let rest = path.slice(prefix.length);
+    if (suffix) {
+        if (!rest.endsWith(suffix))
+            return null;
+        rest = rest.slice(0, -suffix.length);
+    }
+    if (!rest || rest.includes("/"))
+        return null;
+    return rest;
+}

package/dist/bot-store.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataDir = dataDir;
+exports.listBots = listBots;
+exports.getBot = getBot;
+exports.createBot = createBot;
+exports.updateBot = updateBot;
+exports.deleteBot = deleteBot;
+exports.botNeedsSetup = botNeedsSetup;
+exports.ensureSetupThread = ensureSetupThread;
+exports.setSetupStatus = setSetupStatus;
+exports.listThreads = listThreads;
+exports.getThread = getThread;
+exports.createThread = createThread;
+exports.updateThread = updateThread;
+exports.deleteThread = deleteThread;
+exports.bindSession = bindSession;
+exports.touchThread = touchThread;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+// --- Storage ---
+// Two JSON files under ~/.jarvis. Small collections, read fully and written atomically.
+// All access goes through this module so the backing store can be swapped later.
+// ~/.gitbot and ~/.grass are the pre-rename locations: keep using one when it
+// exists and the new directory does not, so an upgrade doesn't orphan someone's
+// bots and threads.
+function resolveDataDir() {
+    if (process.env.JARVIS_DATA_DIR)
+        return process.env.JARVIS_DATA_DIR;
+    if (process.env.GITBOT_DATA_DIR)
+        return process.env.GITBOT_DATA_DIR;
+    if (process.env.GRASS_DATA_DIR)
+        return process.env.GRASS_DATA_DIR;
+    const current = (0, path_1.join)((0, os_1.homedir)(), ".jarvis");
+    if ((0, fs_1.existsSync)(current))
+        return current;
+    for (const legacy of [(0, path_1.join)((0, os_1.homedir)(), ".gitbot"), (0, path_1.join)((0, os_1.homedir)(), ".grass")]) {
+        if ((0, fs_1.existsSync)(legacy))
+            return legacy;
+    }
+    return current;
+}
+const DATA_DIR = resolveDataDir();
+/** The resolved data directory, shared by other modules that persist state. */
+function dataDir() {
+    return DATA_DIR;
+}
+const BOTS_FILE = (0, path_1.join)(DATA_DIR, "bots.json");
+const THREADS_FILE = (0, path_1.join)(DATA_DIR, "threads.json");
+function readCollection(file) {
+    if (!(0, fs_1.existsSync)(file))
+        return [];
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(file, "utf-8"));
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch (err) {
+        console.error(`[bot-store] could not read ${file}: ${err.message}`);
+        return [];
+    }
+}
+function writeCollection(file, items) {
+    if (!(0, fs_1.existsSync)(DATA_DIR))
+        (0, fs_1.mkdirSync)(DATA_DIR, { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    (0, fs_1.writeFileSync)(tmp, JSON.stringify(items, null, 2), "utf-8");
+    (0, fs_1.renameSync)(tmp, file);
+}
+const now = () => new Date().toISOString();
+// --- Bots ---
+function listBots() {
+    return readCollection(BOTS_FILE).sort((a, b) => a.name.localeCompare(b.name));
+}
+function getBot(id) {
+    return readCollection(BOTS_FILE).find((b) => b.id === id);
+}
+function createBot(input) {
+    const bots = readCollection(BOTS_FILE);
+    const ts = now();
+    const bot = {
+        id: (0, crypto_1.randomUUID)(),
+        name: input.name,
+        description: input.description ?? "",
+        emoji: input.emoji ?? "🤖",
+        instructions: input.instructions ?? "",
+        setupInstructions: input.setupInstructions,
+        setupStatus: input.setupInstructions?.trim() ? "pending" : undefined,
+        model: input.model,
+        repoPath: input.repoPath,
+        permissionMode: input.permissionMode ?? "ask-permissions",
+        allowedTools: input.allowedTools,
+        disallowedTools: input.disallowedTools,
+        role: input.role,
+        projectSlug: input.projectSlug,
+        createdAt: ts,
+        updatedAt: ts,
+    };
+    bots.push(bot);
+    writeCollection(BOTS_FILE, bots);
+    return bot;
+}
+function updateBot(id, patch) {
+    const bots = readCollection(BOTS_FILE);
+    const idx = bots.findIndex((b) => b.id === id);
+    if (idx === -1)
+        return undefined;
+    const { id: _ignored, createdAt: _created, ...rest } = patch;
+    const before = bots[idx];
+    const merged = { ...before, ...rest, updatedAt: now() };
+    // Setup state follows the instructions it exists for: gaining them arms a run,
+    // losing them drops it, and rewriting them asks the machine to be prepared
+    // again. An explicit status in the patch is the caller's own call and stands.
+    const had = !!before.setupInstructions?.trim();
+    const has = !!merged.setupInstructions?.trim();
+    if (!has) {
+        merged.setupStatus = undefined;
+        merged.setupThreadId = undefined;
+    }
+    else if (rest.setupStatus === undefined) {
+        if (!had || merged.setupInstructions !== before.setupInstructions)
+            merged.setupStatus = "pending";
+    }
+    bots[idx] = merged;
+    writeCollection(BOTS_FILE, bots);
+    return bots[idx];
+}
+/** Deletes the bot and every thread belonging to it. */
+function deleteBot(id) {
+    const bots = readCollection(BOTS_FILE);
+    const remaining = bots.filter((b) => b.id !== id);
+    if (remaining.length === bots.length)
+        return false;
+    writeCollection(BOTS_FILE, remaining);
+    const threads = readCollection(THREADS_FILE);
+    writeCollection(THREADS_FILE, threads.filter((t) => t.botId !== id));
+    return true;
+}
+// --- Setup ---
+/**
+ * True while this machine still owes the bot a setup run. A bot with no setup
+ * instructions never owes one, so it is usable the moment it lands.
+ */
+function botNeedsSetup(bot) {
+    return !!bot.setupInstructions?.trim() && bot.setupStatus !== "complete";
+}
+/**
+ * The bot's setup thread, created on first ask. The thread is an ordinary
+ * Claude Code conversation — only its kind and its opening prompt differ — so
+ * the user can talk to it when the automatic run does not get all the way there.
+ */
+function ensureSetupThread(botId, fallbackPath) {
+    const bot = getBot(botId);
+    if (!bot || !bot.setupInstructions?.trim())
+        return undefined;
+    const existing = bot.setupThreadId ? getThread(bot.setupThreadId) : undefined;
+    if (existing)
+        return existing;
+    const thread = createThread(bot.id, bot.repoPath || fallbackPath, `Set up ${bot.name}`, "setup");
+    updateBot(bot.id, { setupThreadId: thread.id, setupStatus: bot.setupStatus ?? "pending" });
+    return thread;
+}
+function setSetupStatus(botId, status) {
+    const bot = getBot(botId);
+    if (!bot || !bot.setupInstructions?.trim())
+        return bot;
+    return updateBot(botId, { setupStatus: status });
+}
+// --- Threads ---
+function listThreads(botId) {
+    const threads = readCollection(THREADS_FILE);
+    return threads
+        .filter((t) => !botId || t.botId === botId)
+        .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+function getThread(id) {
+    return readCollection(THREADS_FILE).find((t) => t.id === id);
+}
+function createThread(botId, repoPath, title, kind = "chat") {
+    const threads = readCollection(THREADS_FILE);
+    const ts = now();
+    const thread = {
+        id: (0, crypto_1.randomUUID)(),
+        botId,
+        kind,
+        sdkSessionId: null,
+        title: title ?? defaultTitle(repoPath),
+        titleIsAuto: !title,
+        repoPath,
+        preview: "",
+        messageCount: 0,
+        createdAt: ts,
+        updatedAt: ts,
+    };
+    threads.push(thread);
+    writeCollection(THREADS_FILE, threads);
+    return thread;
+}
+function updateThread(id, patch) {
+    const threads = readCollection(THREADS_FILE);
+    const idx = threads.findIndex((t) => t.id === id);
+    if (idx === -1)
+        return undefined;
+    const { id: _ignored, botId: _bot, createdAt: _created, ...rest } = patch;
+    threads[idx] = { ...threads[idx], ...rest, updatedAt: now() };
+    // A title the caller set by hand is the user's, not ours to overwrite.
+    if (rest.title !== undefined && rest.titleIsAuto === undefined)
+        threads[idx].titleIsAuto = false;
+    writeCollection(THREADS_FILE, threads);
+    return threads[idx];
+}
+function deleteThread(id) {
+    const threads = readCollection(THREADS_FILE);
+    const remaining = threads.filter((t) => t.id !== id);
+    if (remaining.length === threads.length)
+        return false;
+    writeCollection(THREADS_FILE, remaining);
+    return true;
+}
+/**
+ * Binds a thread to the Claude Code session that backs it. Called once, when the
+ * SDK reports its session id on the first turn; that id is the resume handle.
+ */
+function bindSession(id, sdkSessionId) {
+    const thread = getThread(id);
+    if (!thread || thread.sdkSessionId)
+        return thread;
+    return updateThread(id, { sdkSessionId });
+}
+/**
+ * Records a turn on a thread, keeping the title and preview useful in the
+ * thread list.
+ */
+function touchThread(id, prompt) {
+    const thread = getThread(id);
+    if (!thread)
+        return undefined;
+    const patch = { messageCount: thread.messageCount + 1 };
+    if (prompt) {
+        patch.preview = prompt.slice(0, 140);
+        // Conversations open with "hi" as often as not, so keep looking for a name
+        // until a turn actually says what the thread is about.
+        if (thread.titleIsAuto !== false) {
+            const derived = titleFromPrompt(prompt);
+            if (derived) {
+                patch.title = derived;
+                patch.titleIsAuto = false;
+            }
+        }
+    }
+    return updateThread(id, patch);
+}
+/** A thread with no turns yet is named after the folder it will run in. */
+function defaultTitle(repoPath) {
+    const folder = (0, path_1.basename)(repoPath || "").trim();
+    return folder ? `New thread in ${folder}` : "New thread";
+}
+/** Prompts that name nothing: greetings, acknowledgements, nudges. */
+const LOW_SIGNAL = /^(?:hi|hey|hello|yo|sup|hiya|howdy|good (?:morning|afternoon|evening)|greetings|thanks|thank you|ty|ok|okay|k|kk|cool|nice|great|got it|sure|yes|yep|yeah|no|nope|nah|continue|carry on|go on|go ahead|proceed|next|more|again|do it|please do|test|testing|ping|\?+|.)[\s!.,?]*$/i;
+/** Openers that carry no meaning in a list of thread names. */
+const FILLER = /^(?:hey|hi|hello|ok|okay|so|now|please|pls|can you(?: please)?|could you(?: please)?|would you(?: please)?|i want you to|i need you to|i'd like you to|let's|lets|help me|i want to|i need to)\b[\s,:-]*/i;
+/**
+ * Names a thread after a prompt, or returns null when the prompt says too
+ * little to name anything. The aim is a label that reads well in a list: one
+ * short phrase, no markdown scaffolding, no mid-word cut.
+ */
+function titleFromPrompt(prompt) {
+    let text = prompt
+        .replace(/```[\s\S]*?```/g, " ") // fenced code says nothing useful
+        .replace(/`([^`]*)`/g, "$1") // keep inline code, drop the ticks
+        .replace(/^\s*(?:[#>*\-+]+|\d+[.)])\s*/gm, "") // markdown bullets/headings
+        .replace(/\s+/g, " ")
+        .trim();
+    if (LOW_SIGNAL.test(text))
+        return null;
+    // Strip leading pleasantries ("hi, can you please ..."), then cut at the
+    // first sentence end.
+    for (let prev = ""; prev !== text;) {
+        prev = text;
+        text = text.replace(FILLER, "").trim();
+    }
+    const sentence = text.match(/^[^.!?\n]{8,}?(?=[.!?](?:\s|$))/);
+    if (sentence)
+        text = sentence[0].trim();
+    text = text.replace(/[\s,;:.\-]+$/, "");
+    // Two words or a handful of characters is a fragment, not a name.
+    if (text.length < 12 || text.split(" ").length < 3)
+        return null;
+    const MAX = 52;
+    if (text.length > MAX) {
+        const cut = text.slice(0, MAX);
+        const space = cut.lastIndexOf(" ");
+        text = (space > 20 ? cut.slice(0, space) : cut).replace(/[\s,;:.\-]+$/, "") + "\u2026";
+    }
+    return text.charAt(0).toUpperCase() + text.slice(1);
+}