jarvis-hq 0.0.3

package/dist/server-common.js

@@ -0,0 +1,663 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.permissionsEmitter = exports.sessions = exports.TOOL_BLACKLIST = exports.EDIT_TOOLS = exports.PORT_RANGE_END = exports.PORT_RANGE_START = void 0;
+exports.findAvailablePort = findAvailablePort;
+exports.getLocalIP = getLocalIP;
+exports.getPublicIP = getPublicIP;
+exports.getTailscaleIP = getTailscaleIP;
+exports.showQR = showQR;
+exports.showRelayQR = showRelayQR;
+exports.maybeCaffeinate = maybeCaffeinate;
+exports.killCaffeinate = killCaffeinate;
+exports.botPermissionToSession = botPermissionToSession;
+exports.shouldAutoApprove = shouldAutoApprove;
+exports.buildPermissionsDump = buildPermissionsDump;
+exports.buildSessionsDump = buildSessionsDump;
+exports.notifyPermissionsChanged = notifyPermissionsChanged;
+exports.setPushNotificationSender = setPushNotificationSender;
+exports.sendPushViaRelay = sendPushViaRelay;
+exports.notifyNewPermission = notifyNewPermission;
+exports.notifySessionDone = notifySessionDone;
+exports.createSession = createSession;
+exports.scheduleCleanup = scheduleCleanup;
+exports.emitEvent = emitEvent;
+exports.relayTokenPath = relayTokenPath;
+exports.notifySessionStarted = notifySessionStarted;
+exports.notifySessionEnded = notifySessionEnded;
+exports.createHttpServer = createHttpServer;
+exports.setupShutdown = setupShutdown;
+exports.sseHeaders = sseHeaders;
+exports.writeSseEvent = writeSseEvent;
+exports.parseQuery = parseQuery;
+exports.parsePathParam = parsePathParam;
+exports.jsonOk = jsonOk;
+exports.jsonError = jsonError;
+exports.readBody = readBody;
+exports.handleWorkspaceRoutes = handleWorkspaceRoutes;
+const os_1 = require("os");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const node_http_1 = __importDefault(require("node:http"));
+const events_1 = require("events");
+const qrcode_terminal_1 = __importDefault(require("qrcode-terminal"));
+const client_html_1 = require("./client-html");
+const client_vendor_1 = require("./client-vendor");
+const workspace_1 = require("./workspace");
+const SERVER_VERSION = require("../package.json").version;
+// Semver range of client app versions this server build can service.
+// Raise the floor when a breaking protocol change makes old clients incompatible.
+const CLIENT_VERSION_RANGE = ">=1.0.0";
+exports.PORT_RANGE_START = 32100;
+exports.PORT_RANGE_END = 32199;
+function findAvailablePort(startPort, endPort) {
+    return new Promise((resolve, reject) => {
+        const tryPort = (port) => {
+            if (port > endPort) {
+                reject(new Error(`No available port found in range ${startPort}–${endPort}`));
+                return;
+            }
+            const server = node_http_1.default.createServer();
+            server.listen(port, () => {
+                server.close(() => resolve(port));
+            });
+            server.on("error", () => tryPort(port + 1));
+        };
+        tryPort(startPort);
+    });
+}
+function getLocalIP() {
+    const nets = (0, os_1.networkInterfaces)();
+    for (const name of Object.keys(nets)) {
+        for (const net of nets[name]) {
+            if (net.family === "IPv4" && !net.internal) {
+                return net.address;
+            }
+        }
+    }
+    return "localhost";
+}
+function getPublicIP() {
+    return new Promise((resolve) => {
+        node_http_1.default.get("http://api.ipify.org", (res) => {
+            let data = "";
+            res.on("data", (chunk) => { data += chunk; });
+            res.on("end", () => resolve(data.trim() || null));
+            res.on("error", () => resolve(null));
+        }).on("error", () => resolve(null));
+    });
+}
+function getTailscaleIP() {
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)("tailscale", ["status"], { timeout: 2000 }, (err) => {
+            if (err)
+                return resolve(null);
+            (0, child_process_1.execFile)("tailscale", ["ip", "-4"], { timeout: 2000 }, (err, stdout) => {
+                if (err)
+                    return resolve(null);
+                const ip = stdout.trim().split("\n")[0];
+                resolve(ip || null);
+            });
+        });
+    });
+}
+async function showQR(network, port) {
+    let ip;
+    let label;
+    if (network === "tailscale") {
+        const tsIP = await getTailscaleIP();
+        if (!tsIP) {
+            console.error("  Tailscale IP not found. Is Tailscale running?");
+            process.exit(1);
+        }
+        ip = tsIP;
+        label = "Tailscale";
+    }
+    else if (network === "remote-ip") {
+        const publicIP = await getPublicIP();
+        if (!publicIP) {
+            console.error("  Could not determine public IP address.");
+            process.exit(1);
+        }
+        ip = publicIP;
+        label = "Public";
+    }
+    else if (network === "local") {
+        ip = getLocalIP();
+        label = "Local Network";
+    }
+    else {
+        ip = network;
+        label = "Custom";
+    }
+    const url = `http://${ip}:${port}`;
+    console.log(`\n  ${label}  ${url}\n`);
+    const qrCode = await new Promise((resolve) => {
+        qrcode_terminal_1.default.generate(url, { small: true }, (code) => {
+            resolve(code.trimEnd());
+        });
+    });
+    console.log(qrCode);
+}
+async function showRelayQR(relayBaseUrl, token) {
+    // Convert ws(s):// to http(s):// for the app-facing URL
+    const appUrl = relayBaseUrl.replace(/^ws(s?):\/\//, "http$1://") + `/s/${token}`;
+    console.log(`\n  Relay  ${appUrl}\n`);
+    const qrCode = await new Promise((resolve) => {
+        qrcode_terminal_1.default.generate(appUrl, { small: true }, (code) => {
+            resolve(code.trimEnd());
+        });
+    });
+    console.log(qrCode);
+}
+function maybeCaffeinate(enabled) {
+    if (!enabled)
+        return null;
+    try {
+        (0, child_process_1.execSync)("which caffeinate", { stdio: "ignore" });
+    }
+    catch {
+        return null;
+    }
+    const hours = 8;
+    const seconds = hours * 60 * 60;
+    const child = (0, child_process_1.spawn)("caffeinate", ["-t", String(seconds)], {
+        detached: true,
+        stdio: "ignore",
+    });
+    child.unref();
+    console.log(`  caffeinate: running for ${hours}h (pid ${child.pid})`);
+    return child.pid ?? null;
+}
+function killCaffeinate(pid) {
+    if (pid === null)
+        return;
+    try {
+        process.kill(pid);
+    }
+    catch {
+        // already gone
+    }
+}
+exports.EDIT_TOOLS = new Set(["Edit", "Write", "NotebookEdit"]);
+exports.TOOL_BLACKLIST = {
+    "claude-code": new Set(["ExitPlanMode", "AskUserQuestion"]),
+    "opencode": new Set(),
+    "codex": new Set(),
+};
+/**
+ * Bot presets describe permissions in the hub's words; sessions want a
+ * PermissionMode (and, for plan, a run mode). Keep the two vocabularies in sync
+ * here — a preset value with no translation silently ends up asking for
+ * everything.
+ */
+function botPermissionToSession(botMode) {
+    switch (botMode) {
+        case "auto-approve": return { permissionMode: "yolo" };
+        case "plan": return { permissionMode: "yolo", mode: "plan" };
+        default: return { permissionMode: "ask-permissions" };
+    }
+}
+function shouldAutoApprove(agent, toolName, mode) {
+    if (mode === "ask-permissions")
+        return false;
+    if (exports.TOOL_BLACKLIST[agent].has(toolName))
+        return false;
+    if (mode === "yolo")
+        return true;
+    if (mode === "allow-all-edits")
+        return exports.EDIT_TOOLS.has(toolName);
+    return false;
+}
+exports.sessions = new Map();
+// --- Global permissions stream ---
+exports.permissionsEmitter = new events_1.EventEmitter();
+function buildPermissionsDump() {
+    const items = [];
+    for (const store of exports.sessions.values()) {
+        const repoName = store.repoPath.split("/").filter(Boolean).pop() ?? store.repoPath;
+        for (const perm of store.pendingPermissions.values()) {
+            items.push({
+                sessionId: store.gitbotId,
+                sdkSessionId: store.sdkSessionId,
+                agent: store.agent,
+                repoPath: store.repoPath,
+                repoName,
+                toolUseID: perm.toolUseID,
+                toolName: perm.toolName,
+                input: perm.input,
+            });
+        }
+    }
+    return items;
+}
+function buildSessionsDump() {
+    return [...exports.sessions.values()].map(store => ({
+        gitbotId: store.gitbotId,
+        sessionId: store.sdkSessionId,
+        status: store.pendingPermissions.size > 0 ? "awaiting_permissions" : store.status,
+    }));
+}
+function notifyPermissionsChanged() {
+    exports.permissionsEmitter.emit("update", buildPermissionsDump(), buildSessionsDump());
+}
+// --- Push notification bridge (avoids circular import with relay-client) ---
+let _pushSender = null;
+function setPushNotificationSender(fn) {
+    _pushSender = fn;
+}
+function sendPushViaRelay(title, body, data) {
+    _pushSender?.(title, body, data);
+}
+function notifyNewPermission(toolName) {
+    notifyPermissionsChanged();
+    if (exports.permissionsEmitter.listenerCount("update") === 0) {
+        sendPushViaRelay("Permission required", `Jarvis wants to use ${toolName}. Tap to review.`, { type: "permission" });
+    }
+    else {
+        // SSE listener exists but may be stale (iOS keeps connections alive after backgrounding).
+        // Wait 5s — if the permission is still pending the user hasn't responded, so push.
+        setTimeout(() => {
+            if (buildPermissionsDump().length > 0) {
+                sendPushViaRelay("Permission required", `Jarvis wants to use ${toolName}. Tap to review.`, { type: "permission" });
+            }
+        }, 10000);
+    }
+}
+function notifySessionDone(store) {
+    // A turn Jarvis is waiting on reports through Jarvis, not on its own.
+    if (store.silent)
+        return;
+    const repoName = store.repoPath.split("/").filter(Boolean).pop() ?? store.repoPath;
+    let title = "Task complete";
+    let body = `Jarvis finished working on ${repoName}. Tap to see the response.`;
+    if (store.threadId) {
+        // Lazy: bot-store is a leaf module, but keep the import out of the hot path.
+        const { getThread, getBot } = require("./bot-store");
+        const thread = getThread(store.threadId);
+        const bot = thread && getBot(thread.botId);
+        if (thread && bot) {
+            title = bot.name;
+            body = `${thread.title} \u2014 done. Tap to see the result.`;
+        }
+    }
+    const send = () => sendPushViaRelay(title, body, { type: "task_complete", sessionId: store.gitbotId, ...(store.threadId ? { threadId: store.threadId } : {}) });
+    if (store.emitter.listenerCount("event") === 0) {
+        send();
+    }
+    else {
+        setTimeout(send, 2000);
+    }
+}
+function createSession(gitbotId, agent, repoPath, model, mode, permissionMode, bot) {
+    const store = {
+        gitbotId,
+        sdkSessionId: null,
+        agent,
+        repoPath,
+        model,
+        mode,
+        permissionMode: permissionMode ?? "ask-permissions",
+        seq: 0,
+        events: [],
+        status: "running",
+        emitter: new events_1.EventEmitter(),
+        abortController: null,
+        pendingPermissions: new Map(),
+        cleanupTimer: null,
+        threadId: bot?.threadId,
+        botPreset: bot?.preset,
+    };
+    exports.sessions.set(gitbotId, store);
+    return store;
+}
+function scheduleCleanup(_store) {
+    // Session cleanup disabled — sessions are kept in memory indefinitely
+    // if (store.cleanupTimer) clearTimeout(store.cleanupTimer);
+    // store.cleanupTimer = setTimeout(() => {
+    //   sessions.delete(store.gitbotId);
+    // }, 60 * 60 * 1000);
+}
+function emitEvent(store, type, data) {
+    const seq = ++store.seq;
+    const event = { seq, type, ...data };
+    store.events.push(event);
+    store.emitter.emit("event", event);
+}
+/**
+ * Where the relay token lives for a workspace. `.gitbot-relay-token` and
+ * `.grass-relay-token` are the pre-rename names: keep honouring one when it is
+ * the only one present, so an upgrade doesn't hand the relay a brand-new identity.
+ */
+function relayTokenPath(cwd) {
+    const current = (0, path_1.join)(cwd, ".jarvis-relay-token");
+    if ((0, fs_1.existsSync)(current))
+        return current;
+    for (const legacy of [(0, path_1.join)(cwd, ".gitbot-relay-token"), (0, path_1.join)(cwd, ".grass-relay-token")]) {
+        if ((0, fs_1.existsSync)(legacy))
+            return legacy;
+    }
+    return current;
+}
+let _keepAliveInterval = null;
+let _activeSessionCount = 0;
+function _pingActivity() {
+    const apiUrl = "https://api.codeongrass.com/v1";
+    if (!apiUrl)
+        return;
+    let token;
+    try {
+        token = (0, fs_1.readFileSync)(relayTokenPath(process.cwd()), "utf8").trim();
+    }
+    catch {
+        return;
+    }
+    if (!token)
+        return;
+    fetch(`${apiUrl}/containers/activity`, {
+        method: "POST",
+        headers: { "x-relay-token": token },
+        signal: AbortSignal.timeout(10000),
+    }).catch(() => { });
+}
+function notifySessionStarted() {
+    _activeSessionCount++;
+    if (_keepAliveInterval === null) {
+        _pingActivity();
+        _keepAliveInterval = setInterval(_pingActivity, 2 * 60 * 1000);
+    }
+}
+function notifySessionEnded() {
+    _activeSessionCount = Math.max(0, _activeSessionCount - 1);
+    if (_activeSessionCount === 0 && _keepAliveInterval !== null) {
+        clearInterval(_keepAliveInterval);
+        _keepAliveInterval = null;
+    }
+}
+// --- HTTP Server ---
+async function createHttpServer(opts) {
+    const caffeinatePid = maybeCaffeinate(opts.caffeinate);
+    console.log(`  workspace: ${process.cwd()}`);
+    let PORT;
+    if (opts.portOverride !== undefined) {
+        PORT = opts.portOverride;
+        console.log(`  port: ${PORT} (specified)`);
+    }
+    else {
+        try {
+            PORT = await findAvailablePort(exports.PORT_RANGE_START, exports.PORT_RANGE_END);
+            console.log(`  port: ${PORT} (auto-selected from ${exports.PORT_RANGE_START}–${exports.PORT_RANGE_END})`);
+        }
+        catch {
+            console.error(`\n  No available port found in range ${exports.PORT_RANGE_START}–${exports.PORT_RANGE_END}.`);
+            console.error(`  Try stopping other jarvis sessions, or run with -p to specify a port.\n`);
+            process.exit(1);
+        }
+    }
+    const server = node_http_1.default.createServer();
+    // Serve the SPA for GET /
+    server.on("request", (req, res) => {
+        if (req.method === "GET" && (req.url === "/" || req.url === "")) {
+            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+            // Function replacement: the vendor bundles contain `$&`-style sequences
+            // that a string replacement would interpret.
+            res.end(client_html_1.html.replace("<!--vendor-->", () => (0, client_vendor_1.vendorScripts)()));
+        }
+        // All other routes handled by server.ts listener
+    });
+    server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+            console.error(`\n  Port ${PORT} is not available.`);
+            if (opts.portOverride !== undefined) {
+                console.error(`  Please choose a different port with -p, or run without -p to auto-select one.\n`);
+            }
+            else {
+                console.error(`  Try stopping other jarvis sessions, or run with -p to specify a port.\n`);
+            }
+            process.exit(1);
+        }
+        throw err;
+    });
+    await new Promise((resolve) => {
+        server.listen(PORT, async () => {
+            await showQR(opts.network, PORT);
+            resolve();
+        });
+    });
+    return { server, PORT, caffeinatePid };
+}
+function setupShutdown(cleanup, caffeinatePid) {
+    const shutdown = () => {
+        console.log("\nShutting down...");
+        killCaffeinate(caffeinatePid);
+        cleanup();
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("exit", () => killCaffeinate(caffeinatePid));
+    process.on("uncaughtException", (err) => {
+        console.error("Uncaught exception:", err);
+        killCaffeinate(caffeinatePid);
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+        console.error("[jarvis] unhandledRejection — process kept alive:", reason);
+    });
+}
+// --- SSE helper ---
+function sseHeaders() {
+    return {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+        "Access-Control-Allow-Origin": "*",
+    };
+}
+function writeSseEvent(res, event) {
+    if (res.writableEnded)
+        return;
+    res.write(`id: ${event.seq}\nevent: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
+}
+// --- Route helpers ---
+function parseQuery(url) {
+    const idx = url.indexOf("?");
+    if (idx === -1)
+        return {};
+    const params = {};
+    for (const [k, v] of new URLSearchParams(url.slice(idx + 1))) {
+        params[k] = v;
+    }
+    return params;
+}
+function parsePathParam(url, prefix) {
+    const path = url.split("?")[0];
+    if (!path.startsWith(prefix))
+        return null;
+    return path.slice(prefix.length) || null;
+}
+function jsonOk(res, body) {
+    const data = JSON.stringify(body);
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(data);
+}
+/** `extra` rides alongside the message for errors the client acts on, not just shows. */
+function jsonError(res, status, message, extra) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: message, ...extra }));
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let raw = "";
+        req.on("data", (chunk) => { raw += chunk; });
+        req.on("end", () => {
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                resolve({});
+            }
+        });
+        req.on("error", reject);
+    });
+}
+// --- Workspace REST handlers ---
+async function handleWorkspaceRoutes(req, res, workspaceCwd, availableAgents) {
+    const url = req.url ?? "/";
+    const method = req.method ?? "GET";
+    const path = url.split("?")[0];
+    const query = parseQuery(url);
+    if (method === "GET" && path === "/health") {
+        _pingActivity();
+        jsonOk(res, { status: "ok", cwd: workspaceCwd, serverVersion: SERVER_VERSION, clientVersionRange: CLIENT_VERSION_RANGE });
+        return true;
+    }
+    if (method === "GET" && path === "/agents") {
+        jsonOk(res, { agents: availableAgents });
+        return true;
+    }
+    if (method === "GET" && path === "/repos") {
+        const repos = await (0, workspace_1.listRepos)(workspaceCwd);
+        jsonOk(res, { repos });
+        return true;
+    }
+    if (method === "GET" && path === "/repos/details") {
+        const repoPath = query.repoPath;
+        if (!repoPath) {
+            jsonError(res, 400, "repoPath is required");
+            return true;
+        }
+        try {
+            const details = (0, workspace_1.getRepoDetails)(repoPath);
+            jsonOk(res, details);
+        }
+        catch (err) {
+            jsonError(res, 500, err?.message ?? "Failed to get repo details");
+        }
+        return true;
+    }
+    if (method === "POST" && path === "/repos/clone") {
+        const body = await readBody(req);
+        const { url: cloneUrl } = body;
+        if (!cloneUrl) {
+            jsonError(res, 400, "url is required");
+            return true;
+        }
+        try {
+            const clonedPath = (0, workspace_1.cloneRepo)(cloneUrl, workspaceCwd);
+            const { basename } = await import("path");
+            jsonOk(res, { path: clonedPath, name: basename(clonedPath) });
+        }
+        catch (err) {
+            jsonError(res, 500, err?.message ?? "Clone failed");
+        }
+        return true;
+    }
+    if (method === "POST" && path === "/folders") {
+        const body = await readBody(req);
+        const { name } = body;
+        if (!name) {
+            jsonError(res, 400, "name is required");
+            return true;
+        }
+        try {
+            const createdPath = await (0, workspace_1.createFolder)(name, workspaceCwd);
+            const { basename } = await import("path");
+            jsonOk(res, { path: createdPath, name: basename(createdPath) });
+        }
+        catch (err) {
+            jsonError(res, 500, err?.message ?? "Create failed");
+        }
+        return true;
+    }
+    // GET /browse?path= — subdirectories only, for the folder picker. Defaults to
+    // the workspace, but roams the whole filesystem from there.
+    if (method === "GET" && path === "/browse") {
+        try {
+            jsonOk(res, await (0, workspace_1.browseDirs)(query.path ?? workspaceCwd, workspaceCwd));
+        }
+        catch (err) {
+            jsonError(res, 400, err?.message ?? "Failed to browse directory");
+        }
+        return true;
+    }
+    if (method === "GET" && path === "/dir") {
+        const repoPath = query.repoPath;
+        if (!repoPath) {
+            jsonError(res, 400, "repoPath is required");
+            return true;
+        }
+        const targetPath = query.path ?? repoPath;
+        try {
+            const entries = await (0, workspace_1.listDir)(targetPath, repoPath);
+            jsonOk(res, { entries });
+        }
+        catch (err) {
+            jsonError(res, 400, err?.message ?? "Failed to list directory");
+        }
+        return true;
+    }
+    if (method === "GET" && path === "/file") {
+        const repoPath = query.repoPath;
+        const filePath = query.path;
+        if (!repoPath) {
+            jsonError(res, 400, "repoPath is required");
+            return true;
+        }
+        if (!filePath) {
+            jsonError(res, 400, "path is required");
+            return true;
+        }
+        try {
+            const { content, size } = await (0, workspace_1.readFile)(filePath, repoPath);
+            jsonOk(res, { content, size });
+        }
+        catch (err) {
+            jsonError(res, 400, err?.message ?? "Failed to read file");
+        }
+        return true;
+    }
+    if (method === "GET" && path === "/diffs") {
+        const repoPath = query.repoPath ?? workspaceCwd;
+        let diff = "";
+        try {
+            diff = (0, child_process_1.execSync)("git diff HEAD", { cwd: repoPath, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 });
+        }
+        catch {
+            diff = "";
+        }
+        // Append untracked (never-committed) files as synthetic diffs
+        try {
+            const { readFileSync, statSync } = await import("fs");
+            const { join } = await import("path");
+            const untrackedRaw = (0, child_process_1.execSync)("git ls-files --others --exclude-standard", {
+                cwd: repoPath,
+                encoding: "utf-8",
+            }).trim();
+            for (const file of untrackedRaw.split("\n").filter(Boolean)) {
+                try {
+                    const fullPath = join(repoPath, file);
+                    if (statSync(fullPath).size > 1024 * 1024)
+                        continue; // skip files > 1 MB
+                    const content = readFileSync(fullPath, "utf-8");
+                    const lines = content.split("\n");
+                    if (lines[lines.length - 1] === "")
+                        lines.pop();
+                    const hunkLines = lines.map((l) => `+${l}`).join("\n");
+                    diff += `\ndiff --git a/${file} b/${file}\nnew file mode 100644\n--- /dev/null\n+++ b/${file}\n@@ -0,0 +1,${lines.length} @@\n${hunkLines}\n`;
+                }
+                catch {
+                    // binary or unreadable — skip
+                }
+            }
+        }
+        catch {
+            // git ls-files unavailable — skip untracked
+        }
+        jsonOk(res, { diff });
+        return true;
+    }
+    return false;
+}