diffact 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,1011 +0,0 @@
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { Hono } from "hono";
-import { logger } from "hono/logger";
-import { AgentManager } from "./agent-manager.js";
-import { computeCapabilities } from "./capabilities.js";
-import { getCommandRun, getCommandRunOutput, listCommandRuns, startCommandRun, stopCommandRun, } from "./command-runner.js";
-import { listAvailableEditors, openInEditor, } from "./editors.js";
-import { ghGetIssueDetail, ghListIssues, ghListPullRequests } from "./gh.js";
-import { gitCheckoutBranch, gitCommitDiff, gitCommitDiffLineEstimate, gitCommitDiffStream, gitCommitFiles, gitCreateBranch, gitDiff, gitListBranchesPaginated, gitListFileTree, gitListStagedFiles, gitLog, gitShowFile, gitStagePaths, gitUnstagePaths, } from "./git.js";
-import { jsonResponse, mapErrorResponse, optionsResponse, readJson, streamResponse, textResponse, withCors, } from "./http.js";
-import { listDirectories } from "./list-directories.js";
-import { log } from "./log.js";
-import { openBrowser } from "./open-browser.js";
-import { listProjectCommands, resolveCommandPlan, } from "./project-commands.js";
-import { resolveProjectRoot } from "./project-path.js";
-import { runtime } from "./runtime.js";
-import { getStaticDir, isStaticEnabled, serveStatic } from "./static.js";
-import { WsHub } from "./ws-hub.js";
-const PROJECT_ROOT = process.env.DIFFACT_PROJECT_ROOT
-    ? path.resolve(process.env.DIFFACT_PROJECT_ROOT)
-    : path.join(os.homedir(), "workspace");
-const PORT = Number.parseInt(process.env.PORT || "", 10) || 4312;
-const INLINE_DIFF_LINE_LIMIT = Number.parseInt(process.env.DIFFACT_INLINE_DIFF_LINES || "", 10) || 4000;
-const stripAnsi = (value) => value.replace(/\u001b\[[0-9;]*m/g, "");
-const decodePercents = (value) => value.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
-    try {
-        return decodeURIComponent(match);
-    }
-    catch {
-        return match;
-    }
-});
-const readStringField = (record, key) => {
-    const value = record[key];
-    return typeof value === "string" ? value.trim() : "";
-};
-const readOptionalNumberField = (record, key) => {
-    const value = record[key];
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        return null;
-    }
-    return value;
-};
-const readOptionalStringField = (record, key) => {
-    const value = record[key];
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed ? trimmed : undefined;
-};
-const readStringArrayField = (record, key) => {
-    const value = record[key];
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value
-        .filter((entry) => typeof entry === "string")
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-};
-const normalizeProjectPaths = (rootPath, paths) => {
-    const unique = new Set();
-    for (const raw of paths) {
-        const trimmed = raw.trim();
-        if (!trimmed) {
-            continue;
-        }
-        const resolved = path.resolve(rootPath, trimmed);
-        const relative = path.relative(rootPath, resolved);
-        if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
-            return null;
-        }
-        unique.add(relative.replace(/\\/g, "/"));
-    }
-    return Array.from(unique.values());
-};
-const isCommandSource = (value) => value === "package.json" || value === "makefile" || value === "custom";
-const toCommandDescriptor = (command) => ({
-    id: command.id,
-    name: command.name,
-    label: command.label,
-    source: command.source,
-});
-const toCommandRunSummary = (record, includeOutput) => ({
-    runId: record.id,
-    projectPath: record.projectRoot,
-    terminalId: record.terminalId,
-    commandId: record.command.id,
-    commandName: record.command.name,
-    commandLabel: record.command.label,
-    commandSource: record.command.source,
-    status: record.status,
-    exitCode: record.exitCode,
-    signal: record.signal,
-    startedAt: record.startedAt,
-    completedAt: record.completedAt ?? null,
-    stdout: includeOutput ? record.output.stdout : undefined,
-    stderr: includeOutput ? record.output.stderr : undefined,
-});
-const shouldIncludeOutput = (record) => record.status !== "running";
-const buildShellPlan = (cwd, commandLine) => ({
-    command: commandLine,
-    args: [],
-    cwd,
-    commandLine,
-});
-const CONTENT_TYPES = {
-    avif: "image/avif",
-    bmp: "image/bmp",
-    gif: "image/gif",
-    ico: "image/x-icon",
-    jpeg: "image/jpeg",
-    jpg: "image/jpeg",
-    png: "image/png",
-    svg: "image/svg+xml",
-    webp: "image/webp",
-    mp4: "video/mp4",
-    mov: "video/quicktime",
-    ogv: "video/ogg",
-    webm: "video/webm",
-    mp3: "audio/mpeg",
-    m4a: "audio/mp4",
-    ogg: "audio/ogg",
-    wav: "audio/wav",
-    flac: "audio/flac",
-    pdf: "application/pdf",
-};
-const guessContentType = (filePath) => {
-    const ext = path.extname(filePath).slice(1).toLowerCase();
-    return CONTENT_TYPES[ext] || "application/octet-stream";
-};
-const hub = new WsHub();
-const agentManager = new AgentManager({ hub });
-hub.setCommandHandler(async ({ clientId, message }) => {
-    const { type, payload, requestId } = message;
-    if (!type) {
-        return;
-    }
-    const sendAck = (result) => {
-        if (!requestId) {
-            return;
-        }
-        hub.sendToClient(clientId, "command_ack", { requestId, result });
-    };
-    const sendError = (error) => {
-        if (!requestId) {
-            return;
-        }
-        hub.sendToClient(clientId, "command_error", { requestId, error });
-    };
-    try {
-        if (type === "agent_start") {
-            if (!payload || typeof payload !== "object") {
-                throw new Error("invalid_payload");
-            }
-            const record = payload;
-            const projectPath = readStringField(record, "projectPath");
-            const prompt = readStringField(record, "prompt");
-            const label = readOptionalStringField(record, "label");
-            if (!projectPath || !prompt) {
-                throw new Error("invalid_payload");
-            }
-            const agent = await agentManager.startAgent({
-                projectPath,
-                prompt,
-                label,
-            });
-            sendAck({ agent });
-            return;
-        }
-        if (type === "thread_message") {
-            if (!payload || typeof payload !== "object") {
-                throw new Error("invalid_payload");
-            }
-            const record = payload;
-            const threadId = readStringField(record, "threadId");
-            const projectPath = readStringField(record, "projectPath");
-            const text = readStringField(record, "text");
-            const label = readOptionalStringField(record, "label");
-            if (!threadId || !projectPath || !text) {
-                throw new Error("invalid_payload");
-            }
-            const agent = await agentManager.resumeThread({
-                threadId,
-                projectPath,
-                label,
-            });
-            const sent = await agentManager.sendMessage(agent.id, text);
-            if (!sent) {
-                throw new Error("agent_not_found");
-            }
-            sendAck({ agentId: agent.id, threadId: agent.threadId ?? threadId });
-            return;
-        }
-        if (type === "agent_stop") {
-            if (!payload || typeof payload !== "object") {
-                throw new Error("invalid_payload");
-            }
-            const record = payload;
-            const agentId = readOptionalStringField(record, "agentId");
-            const threadId = readOptionalStringField(record, "threadId");
-            let stopped = false;
-            if (agentId) {
-                stopped = agentManager.stopAgent(agentId);
-            }
-            else if (threadId) {
-                stopped = agentManager.stopThread(threadId);
-            }
-            if (!stopped) {
-                throw new Error("agent_not_found");
-            }
-            sendAck({ agentId: agentId ?? null, threadId: threadId ?? null });
-            return;
-        }
-        if (type === "terminal_start") {
-            if (!payload || typeof payload !== "object") {
-                throw new Error("invalid_payload");
-            }
-            const record = payload;
-            const projectPath = readStringField(record, "projectPath");
-            const source = readStringField(record, "source");
-            const name = readStringField(record, "name");
-            const cols = readOptionalNumberField(record, "cols");
-            const rows = readOptionalNumberField(record, "rows");
-            if (!projectPath || !source || !name || !isCommandSource(source)) {
-                throw new Error("invalid_payload");
-            }
-            const project = await resolveProjectRoot(projectPath);
-            const commands = await listProjectCommands(project.rootPath);
-            const command = commands.find((item) => item.source === source && item.name === name);
-            if (!command) {
-                throw new Error("command_not_found");
-            }
-            const plan = resolveCommandPlan(project.rootPath, source, name);
-            if (!plan) {
-                throw new Error("command_unsupported");
-            }
-            const result = await startCommandRun({
-                command: toCommandDescriptor(command),
-                projectRoot: project.rootPath,
-                plan,
-                terminal: cols && rows
-                    ? {
-                        cols,
-                        rows,
-                    }
-                    : undefined,
-                listener: {
-                    onOutput: (event) => {
-                        const run = getCommandRun(event.runId);
-                        hub.send("terminal_output", {
-                            projectPath: project.rootPath,
-                            runId: event.runId,
-                            terminalId: run?.terminalId,
-                            stream: event.stream,
-                            data: event.data,
-                        });
-                    },
-                    onStatus: (run) => {
-                        hub.send("terminal_status", {
-                            projectPath: project.rootPath,
-                            run: toCommandRunSummary(run, shouldIncludeOutput(run)),
-                        });
-                    },
-                },
-            });
-            if (!result.runId) {
-                throw new Error(result.error || "command_failed");
-            }
-            const run = getCommandRun(result.runId);
-            if (!run) {
-                throw new Error("command_not_found");
-            }
-            sendAck({ run: toCommandRunSummary(run, shouldIncludeOutput(run)) });
-            return;
-        }
-        if (type === "terminal_exec") {
-            if (!payload || typeof payload !== "object") {
-                throw new Error("invalid_payload");
-            }
-            const record = payload;
-            const projectPath = readStringField(record, "projectPath");
-            const commandLine = readStringField(record, "command");
-            const label = readOptionalStringField(record, "label");
-            const name = readOptionalStringField(record, "name");
-            const cols = readOptionalNumberField(record, "cols");
-            const rows = readOptionalNumberField(record, "rows");
-            if (!projectPath || !commandLine) {
-                throw new Error("invalid_payload");
-            }
-            const project = await resolveProjectRoot(projectPath);
-            const plan = buildShellPlan(project.rootPath, commandLine);
-            const commandLabel = label || name || "Custom Command";
-            const commandName = name || label || "custom";
-            const descriptor = {
-                id: `custom:${commandName}`,
-                name: commandName,
-                label: commandLabel,
-                source: "custom",
-            };
-            const result = await startCommandRun({
-                command: descriptor,
-                projectRoot: project.rootPath,
-                plan,
-                terminal: cols && rows
-                    ? {
-                        cols,
-                        rows,
-                    }
-                    : undefined,
-                listener: {
-                    onOutput: (event) => {
-                        const run = getCommandRun(event.runId);
-                        hub.send("terminal_output", {
-                            projectPath: project.rootPath,
-                            runId: event.runId,
-                            terminalId: run?.terminalId,
-                            stream: event.stream,
-                            data: event.data,
-                        });
-                    },
-                    onStatus: (run) => {
-                        hub.send("terminal_status", {
-                            projectPath: project.rootPath,
-                            run: toCommandRunSummary(run, shouldIncludeOutput(run)),
-                        });
-                    },
-                },
-            });
-            if (!result.runId) {
-                throw new Error(result.error || "command_failed");
-            }
-            const run = getCommandRun(result.runId);
-            if (!run) {
-                throw new Error("command_not_found");
-            }
-            sendAck({ run: toCommandRunSummary(run, shouldIncludeOutput(run)) });
-            return;
-        }
-        if (type === "terminal_stop") {
-            if (!payload || typeof payload !== "object") {
-                throw new Error("invalid_payload");
-            }
-            const record = payload;
-            const projectPath = readStringField(record, "projectPath");
-            const runId = readStringField(record, "runId");
-            if (!projectPath || !runId) {
-                throw new Error("invalid_payload");
-            }
-            const project = await resolveProjectRoot(projectPath);
-            const existing = getCommandRun(runId);
-            if (!existing || existing.projectRoot !== project.rootPath) {
-                throw new Error("command_not_found");
-            }
-            const run = stopCommandRun(runId);
-            if (!run) {
-                throw new Error("command_not_found");
-            }
-            sendAck({ run: toCommandRunSummary(run, shouldIncludeOutput(run)) });
-            return;
-        }
-        if (type === "terminal_list") {
-            if (!payload || typeof payload !== "object") {
-                throw new Error("invalid_payload");
-            }
-            const record = payload;
-            const projectPath = readStringField(record, "projectPath");
-            if (!projectPath) {
-                throw new Error("invalid_payload");
-            }
-            const project = await resolveProjectRoot(projectPath);
-            const runs = listCommandRuns(project.rootPath)
-                .sort((a, b) => b.startedAt.localeCompare(a.startedAt))
-                .map((run) => toCommandRunSummary(run, true));
-            sendAck({ runs });
-            return;
-        }
-        if (type === "terminal_output") {
-            if (!payload || typeof payload !== "object") {
-                throw new Error("invalid_payload");
-            }
-            const record = payload;
-            const projectPath = readStringField(record, "projectPath");
-            const runId = readStringField(record, "runId");
-            if (!projectPath || !runId) {
-                throw new Error("invalid_payload");
-            }
-            const project = await resolveProjectRoot(projectPath);
-            const existing = getCommandRun(runId);
-            if (!existing || existing.projectRoot !== project.rootPath) {
-                throw new Error("command_not_found");
-            }
-            const output = getCommandRunOutput(runId);
-            if (!output) {
-                throw new Error("command_not_found");
-            }
-            sendAck({ stdout: output.stdout, stderr: output.stderr });
-            return;
-        }
-        log.warn({ type }, "ws unknown command");
-        sendError("unknown_command");
-    }
-    catch (error) {
-        const messageText = error instanceof Error ? error.message : "command_failed";
-        sendError(messageText);
-    }
-});
-const app = new Hono();
-app.use("*", logger((message, ...rest) => {
-    log.info({ rest }, decodePercents(stripAnsi(message)));
-}));
-app.onError((error, c) => {
-    log.error({ err: error, path: c.req.path, method: c.req.method }, "error");
-    return mapErrorResponse(error);
-});
-app.options("*", () => optionsResponse());
-app.get("/health", () => jsonResponse(200, {
-    status: "ok",
-    time: new Date().toISOString(),
-}));
-// WebSocket route is registered dynamically based on runtime (see bottom of file)
-app.get("/api/capabilities", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project");
-    const capabilities = await computeCapabilities(projectPath);
-    return jsonResponse(200, capabilities);
-});
-app.get("/api/editors", async () => {
-    const editors = await listAvailableEditors();
-    return jsonResponse(200, { editors });
-});
-app.post("/api/editors/open", async (c) => {
-    const body = (await readJson(c.req.raw));
-    if (!body || !body.editor || !body.project) {
-        return jsonResponse(400, { error: "invalid_payload" });
-    }
-    const editorId = body.editor;
-    if (!["vscode", "cursor", "zed"].includes(editorId)) {
-        return jsonResponse(400, { error: "invalid_editor" });
-    }
-    const target = body.target ?? { type: "project" };
-    const result = await openInEditor(editorId, body.project, target);
-    if (!result.success) {
-        return jsonResponse(400, { error: result.error ?? "open_failed" });
-    }
-    return jsonResponse(200, { success: true });
-});
-app.get("/api/projects/browse", async (c) => {
-    const url = new URL(c.req.url);
-    const targetPath = url.searchParams.get("path")?.trim();
-    const listing = await listDirectories(targetPath || PROJECT_ROOT);
-    return jsonResponse(200, listing);
-});
-app.post("/api/projects/open", async (c) => {
-    const body = (await readJson(c.req.raw));
-    if (!body || typeof body.path !== "string") {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(body.path);
-    return jsonResponse(200, project);
-});
-app.get("/api/projects/commands", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    const commands = await listProjectCommands(project.rootPath);
-    return jsonResponse(200, { commands });
-});
-app.post("/api/projects/commands/run", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const body = (await readJson(c.req.raw));
-    if (!body) {
-        return jsonResponse(400, { error: "invalid_command" });
-    }
-    const source = readStringField(body, "source");
-    const name = readStringField(body, "name");
-    if (!source || !name || !isCommandSource(source)) {
-        return jsonResponse(400, { error: "invalid_command" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    const commands = await listProjectCommands(project.rootPath);
-    const command = commands.find((item) => item.source === source && item.name === name);
-    if (!command) {
-        return jsonResponse(404, { error: "command_not_found" });
-    }
-    const plan = resolveCommandPlan(project.rootPath, source, name);
-    if (!plan) {
-        return jsonResponse(400, { error: "command_unsupported" });
-    }
-    const result = await startCommandRun({
-        command: toCommandDescriptor(command),
-        projectRoot: project.rootPath,
-        plan,
-    });
-    return jsonResponse(200, result);
-});
-app.get("/api/projects/commands/runs/:id", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const runId = c.req.param("id")?.trim();
-    if (!projectPath || !runId) {
-        return jsonResponse(400, { error: "invalid_command" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    const record = getCommandRun(runId);
-    if (!record || record.projectRoot !== project.rootPath) {
-        return jsonResponse(404, { error: "command_not_found" });
-    }
-    return jsonResponse(200, {
-        status: record.status,
-        exitCode: record.exitCode,
-        signal: record.signal,
-    });
-});
-app.post("/api/projects/commands/runs/:id/stop", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const runId = c.req.param("id")?.trim();
-    if (!projectPath || !runId) {
-        return jsonResponse(400, { error: "invalid_command" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    const existing = getCommandRun(runId);
-    if (!existing || existing.projectRoot !== project.rootPath) {
-        return jsonResponse(404, { error: "command_not_found" });
-    }
-    const record = stopCommandRun(runId);
-    if (!record) {
-        return jsonResponse(404, { error: "command_not_found" });
-    }
-    return jsonResponse(200, {
-        status: record.status,
-        exitCode: record.exitCode,
-        signal: record.signal,
-    });
-});
-app.get("/api/projects/diff", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return textResponse(200, "");
-    }
-    const args = url.searchParams.getAll("arg").filter(Boolean);
-    const paths = url.searchParams.getAll("path").filter(Boolean);
-    const diff = await gitDiff(project.rootPath, args, paths);
-    return textResponse(200, diff);
-});
-app.get("/api/projects/staged", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(200, { paths: [] });
-    }
-    const paths = await gitListStagedFiles(project.rootPath);
-    return jsonResponse(200, { paths });
-});
-app.post("/api/projects/stage", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const body = (await readJson(c.req.raw));
-    if (!body) {
-        return jsonResponse(400, { error: "invalid_payload" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    const stagedValue = body.staged;
-    if (typeof stagedValue !== "boolean") {
-        return jsonResponse(400, { error: "invalid_payload" });
-    }
-    const pathValue = readStringField(body, "path");
-    const pathsValue = readStringArrayField(body, "paths");
-    const requestedPaths = pathsValue.length
-        ? pathsValue
-        : pathValue
-            ? [pathValue]
-            : [];
-    if (!requestedPaths.length) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const normalized = normalizeProjectPaths(project.rootPath, requestedPaths);
-    if (!normalized || !normalized.length) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    if (stagedValue) {
-        await gitStagePaths(project.rootPath, normalized);
-    }
-    else {
-        await gitUnstagePaths(project.rootPath, normalized);
-    }
-    return jsonResponse(200, { paths: normalized, staged: stagedValue });
-});
-app.get("/api/projects/tree", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(200, {
-            available: false,
-            rootPath: project.rootPath,
-            entries: [],
-        });
-    }
-    const entries = await gitListFileTree(project.rootPath);
-    return jsonResponse(200, {
-        available: true,
-        rootPath: project.rootPath,
-        entries,
-    });
-});
-app.get("/api/projects/file", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const filePath = url.searchParams.get("path")?.trim();
-    const ref = url.searchParams.get("ref")?.trim();
-    if (!projectPath || !filePath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    const resolved = path.resolve(project.rootPath, filePath);
-    const relative = path.relative(project.rootPath, resolved);
-    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const normalizedPath = relative.replace(/\\/g, "/");
-    if (ref) {
-        try {
-            const contents = await gitShowFile(project.rootPath, ref, normalizedPath);
-            return jsonResponse(200, { path: filePath, contents });
-        }
-        catch (error) {
-            if (error && typeof error === "object" && "code" in error) {
-                const { code } = error;
-                if (code === 128) {
-                    return jsonResponse(404, { error: "invalid_path" });
-                }
-            }
-            throw error;
-        }
-    }
-    let stat;
-    try {
-        stat = await fs.stat(resolved);
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error) {
-            if (error.code === "ENOENT") {
-                return jsonResponse(404, { error: "invalid_path" });
-            }
-        }
-        throw error;
-    }
-    if (!stat.isFile()) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const contents = await fs.readFile(resolved, "utf8");
-    return jsonResponse(200, { path: filePath, contents });
-});
-app.get("/api/projects/file/raw", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const filePath = url.searchParams.get("path")?.trim();
-    if (!projectPath || !filePath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    const resolved = path.resolve(project.rootPath, filePath);
-    const relative = path.relative(project.rootPath, resolved);
-    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    let stat;
-    try {
-        stat = await fs.stat(resolved);
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error) {
-            if (error.code === "ENOENT") {
-                return jsonResponse(404, { error: "invalid_path" });
-            }
-        }
-        throw error;
-    }
-    if (!stat.isFile()) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const file = runtime.file(resolved);
-    const response = new Response(file.stream(), {
-        status: 200,
-        headers: {
-            "Content-Type": guessContentType(resolved),
-            "Content-Disposition": "inline",
-        },
-    });
-    return withCors(response);
-});
-app.get("/api/projects/history", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    const limitParam = url.searchParams.get("limit");
-    const skipParam = url.searchParams.get("skip");
-    const limit = limitParam ? Number.parseInt(limitParam, 10) : 30;
-    const skip = skipParam ? Number.parseInt(skipParam, 10) : 0;
-    const safeLimit = Number.isFinite(limit) && limit > 0 ? Math.min(200, limit) : 30;
-    const safeSkip = Number.isFinite(skip) && skip > 0 ? skip : 0;
-    const page = await gitLog(project.rootPath, safeSkip, safeLimit);
-    return jsonResponse(200, page);
-});
-app.get("/api/projects/commits/:sha/diff", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const sha = c.req.param("sha")?.trim();
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    if (!sha) {
-        return jsonResponse(400, { error: "invalid_commit" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    let estimate = null;
-    try {
-        estimate = await gitCommitDiffLineEstimate(project.rootPath, sha);
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error) {
-            const { code } = error;
-            if (code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
-                estimate = null;
-            }
-            else {
-                throw error;
-            }
-        }
-        else {
-            throw error;
-        }
-    }
-    const shouldStream = estimate === null || estimate > INLINE_DIFF_LINE_LIMIT;
-    if (!shouldStream) {
-        const diff = await gitCommitDiff(project.rootPath, sha);
-        return textResponse(200, diff);
-    }
-    const stream = gitCommitDiffStream(project.rootPath, sha);
-    return streamResponse(200, stream);
-});
-app.get("/api/projects/commits/:sha/files", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const sha = c.req.param("sha")?.trim();
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    if (!sha) {
-        return jsonResponse(400, { error: "invalid_commit" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    const files = await gitCommitFiles(project.rootPath, sha);
-    return jsonResponse(200, files);
-});
-app.get("/api/projects/branches", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const cursor = url.searchParams.get("cursor")?.trim() || null;
-    const filter = url.searchParams.get("filter")?.trim() || null;
-    const limitParam = url.searchParams.get("limit");
-    const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined;
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    const listing = await gitListBranchesPaginated(project.rootPath, {
-        limit,
-        cursor,
-        filter,
-    });
-    return jsonResponse(200, listing);
-});
-app.post("/api/projects/branches", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const body = (await readJson(c.req.raw));
-    const name = body?.name?.trim() ?? "";
-    if (!name) {
-        return jsonResponse(400, { error: "invalid_branch" });
-    }
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    await gitCreateBranch(project.rootPath, name);
-    return jsonResponse(201, { name });
-});
-app.post("/api/projects/branches/checkout", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const body = (await readJson(c.req.raw));
-    const name = body?.name?.trim() ?? "";
-    if (!name) {
-        return jsonResponse(400, { error: "invalid_branch" });
-    }
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    await gitCheckoutBranch(project.rootPath, name);
-    return jsonResponse(200, { name });
-});
-app.get("/api/projects/pull-requests", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const cursor = url.searchParams.get("cursor")?.trim() || null;
-    const search = url.searchParams.get("search")?.trim() || null;
-    const limitParam = url.searchParams.get("limit");
-    const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined;
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    const listing = await ghListPullRequests(project.rootPath, {
-        limit,
-        cursor,
-        search,
-    });
-    return jsonResponse(200, listing);
-});
-app.get("/api/projects/issues", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const cursor = url.searchParams.get("cursor")?.trim() || null;
-    const search = url.searchParams.get("search")?.trim() || null;
-    const state = url.searchParams.get("state")?.trim();
-    const limitParam = url.searchParams.get("limit");
-    const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined;
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    const listing = await ghListIssues(project.rootPath, {
-        limit,
-        cursor,
-        search,
-        state: state || "open",
-    });
-    return jsonResponse(200, listing);
-});
-app.get("/api/projects/issues/:number", async (c) => {
-    const url = new URL(c.req.url);
-    const projectPath = url.searchParams.get("project")?.trim();
-    const issueNumber = Number.parseInt(c.req.param("number") || "", 10);
-    if (!projectPath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    if (Number.isNaN(issueNumber)) {
-        return jsonResponse(400, { error: "invalid_issue_number" });
-    }
-    const project = await resolveProjectRoot(projectPath);
-    if (!project.isGit) {
-        return jsonResponse(400, { error: "project_not_git" });
-    }
-    const detail = await ghGetIssueDetail(project.rootPath, issueNumber);
-    if (!detail) {
-        return jsonResponse(404, { error: "issue_not_found" });
-    }
-    return jsonResponse(200, detail);
-});
-app.get("/api/agents", () => jsonResponse(200, agentManager.listAgents()));
-app.get("/api/agents/:id", (c) => {
-    const agentId = c.req.param("id");
-    const agent = agentManager.getAgent(agentId);
-    if (!agent) {
-        return jsonResponse(404, { error: "agent_not_found" });
-    }
-    return jsonResponse(200, agent);
-});
-app.get("/api/threads", async (c) => {
-    const url = new URL(c.req.url);
-    const cursor = url.searchParams.get("cursor");
-    const limitParam = url.searchParams.get("limit");
-    const projectParam = url.searchParams.get("project")?.trim();
-    const limit = limitParam ? Number.parseInt(limitParam, 10) : null;
-    const projectPath = projectParam
-        ? (await resolveProjectRoot(projectParam)).rootPath
-        : null;
-    const result = await agentManager.listThreads({
-        cursor: cursor || null,
-        limit: Number.isNaN(limit) ? null : limit,
-        projectPath,
-    });
-    return jsonResponse(200, result);
-});
-app.get("/api/threads/history", async (c) => {
-    const url = new URL(c.req.url);
-    const filePath = url.searchParams.get("path")?.trim();
-    if (!filePath) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const resolved = path.resolve(filePath);
-    if (path.extname(resolved).toLowerCase() !== ".jsonl") {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    let stat;
-    try {
-        stat = await fs.stat(resolved);
-    }
-    catch (error) {
-        if (error && typeof error === "object" && "code" in error) {
-            if (error.code === "ENOENT") {
-                return jsonResponse(404, { error: "invalid_path" });
-            }
-        }
-        throw error;
-    }
-    if (!stat.isFile()) {
-        return jsonResponse(400, { error: "invalid_path" });
-    }
-    const contents = await fs.readFile(resolved, "utf8");
-    return textResponse(200, contents);
-});
-// Static file serving (SPA fallback)
-app.get("*", async (c) => {
-    const reqPath = new URL(c.req.url).pathname;
-    const response = await serveStatic(reqPath);
-    if (response)
-        return response;
-    return textResponse(404, "Not found");
-});
-// Export app and hub for external server adapters
-export { app, hub, PORT };
-// CLI flags
-const NO_OPEN = process.argv.includes("--no-open");
-// Start server based on runtime
-if (runtime.isBun) {
-    const { upgradeWebSocket, websocket } = await import("hono/bun");
-    // Re-register WebSocket route with Bun adapter
-    app.get("/api/events", upgradeWebSocket(() => {
-        log.info("ws open");
-        return hub.open();
-    }));
-    Bun.serve({
-        port: PORT,
-        fetch: app.fetch,
-        websocket,
-    });
-    const url = `http://localhost:${PORT}`;
-    log.info(`diffact server listening on ${url}`);
-    if (isStaticEnabled()) {
-        log.info(`serving static files from ${getStaticDir()}`);
-    }
-    if (!NO_OPEN && isStaticEnabled()) {
-        openBrowser(url);
-    }
-}