@ouro.bot/cli 0.1.0-alpha.55 → 0.1.0-alpha.551

package/dist/heart/mail-import-discovery.js

@@ -0,0 +1,353 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultMailImportDiscoveryDirs = defaultMailImportDiscoveryDirs;
+exports.listDiscoveredMboxCandidates = listDiscoveredMboxCandidates;
+exports.rankDiscoveredMboxCandidates = rankDiscoveredMboxCandidates;
+exports.discoverMailImportFilePath = discoverMailImportFilePath;
+exports.listAmbientMailImportOperations = listAmbientMailImportOperations;
+exports.listVisibleBackgroundOperations = listVisibleBackgroundOperations;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const background_operations_1 = require("./background-operations");
+const identity = __importStar(require("./identity"));
+const DEFAULT_RECENT_IMPORT_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_VISIBLE_BACKGROUND_OPERATION_LIMIT = 5;
+const DEFAULT_VISIBLE_IMPORT_CANDIDATE_LIMIT = 3;
+const DEFAULT_WORKTREE_POOL_SEARCH_DEPTH = 2;
+const DEFAULT_AGENT_WORKSPACE_SCAN_LIMIT = 20;
+const SKIPPED_HOME_SCAN_DIRS = new Set([
+    ".Trash",
+    "Applications",
+    "Library",
+    "Movies",
+    "Music",
+    "Pictures",
+    "Public",
+    "node_modules",
+]);
+function sortBackgroundOperationsNewestFirst(left, right) {
+    return Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
+}
+function recentImportFingerprint(candidates) {
+    return candidates
+        .map((candidate) => `${candidate.path}:${candidate.mtimeMs}`)
+        .sort((left, right) => left.localeCompare(right))
+        .join("|");
+}
+function specText(spec, key) {
+    const value = spec?.[key];
+    return typeof value === "string" ? value.trim() : "";
+}
+function latestComparableOperationTimestamp(record) {
+    const fileModifiedAt = specText(record.spec, "fileModifiedAt");
+    if (fileModifiedAt) {
+        const parsed = Date.parse(fileModifiedAt);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    const candidates = [record.finishedAt, record.updatedAt];
+    for (const candidate of candidates) {
+        if (typeof candidate !== "string")
+            continue;
+        const parsed = Date.parse(candidate);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return null;
+}
+function candidateAlreadyCoveredByOperation(candidate, operation) {
+    if (operation.kind !== "mail.import-mbox")
+        return false;
+    if (specText(operation.spec, "filePath") !== candidate.path)
+        return false;
+    if (operation.status !== "succeeded")
+        return false;
+    const operationTimestamp = latestComparableOperationTimestamp(operation);
+    return operationTimestamp !== null && candidate.mtimeMs <= operationTimestamp;
+}
+function listChildDirs(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(dir, entry.name));
+    }
+    catch {
+        return [];
+    }
+}
+function classifyDiscoveredMboxOrigin(dir) {
+    const normalizedDir = path.resolve(dir);
+    const parts = normalizedDir.split(path.sep).filter(Boolean);
+    if (parts.includes(".playwright-mcp")) {
+        return {
+            originKind: "playwright-sandbox",
+            originLabel: "browser sandbox (.playwright-mcp)",
+        };
+    }
+    if (path.basename(normalizedDir) === "Downloads") {
+        return {
+            originKind: "downloads",
+            originLabel: "Downloads",
+        };
+    }
+    return {
+        originKind: "filesystem",
+        originLabel: "filesystem",
+    };
+}
+function findWorktreePools(rootDir, maxDepth) {
+    const seen = new Set();
+    const found = [];
+    function visit(currentDir, depth) {
+        if (depth > maxDepth || seen.has(currentDir))
+            return;
+        seen.add(currentDir);
+        let entries;
+        try {
+            entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith(".") && entry.name !== ".playwright-mcp")
+                continue;
+            if (SKIPPED_HOME_SCAN_DIRS.has(entry.name))
+                continue;
+            const childDir = path.join(currentDir, entry.name);
+            if (entry.name === "_worktrees") {
+                found.push(childDir);
+                continue;
+            }
+            visit(childDir, depth + 1);
+        }
+    }
+    visit(rootDir, 0);
+    return found;
+}
+function listAgentWorkspaceSandboxDirs(agentName) {
+    if (!agentName)
+        return [];
+    const getAgentRepoWorkspacesRoot = Object.getOwnPropertyDescriptor(identity, "getAgentRepoWorkspacesRoot")?.value;
+    const workspacesRoot = typeof getAgentRepoWorkspacesRoot === "function"
+        ? getAgentRepoWorkspacesRoot(agentName)
+        : "";
+    if (!workspacesRoot)
+        return [];
+    return listChildDirs(workspacesRoot)
+        .slice(0, DEFAULT_AGENT_WORKSPACE_SCAN_LIMIT)
+        .map((workspaceDir) => path.join(workspaceDir, ".playwright-mcp"));
+}
+function listWorktreePoolSandboxDirs(homeDir) {
+    return findWorktreePools(homeDir, DEFAULT_WORKTREE_POOL_SEARCH_DEPTH)
+        .flatMap((poolDir) => listChildDirs(poolDir))
+        .map((worktreeDir) => path.join(worktreeDir, ".playwright-mcp"));
+}
+function defaultMailImportDiscoveryDirs(input = {}) {
+    const repoRoot = path.resolve(input.repoRoot ?? process.cwd());
+    const homeDir = path.resolve(input.homeDir ?? os.homedir());
+    return [...new Set([
+            path.join(repoRoot, ".playwright-mcp"),
+            ...listAgentWorkspaceSandboxDirs(input.agentName),
+            ...listWorktreePoolSandboxDirs(homeDir),
+            path.join(homeDir, ".playwright-mcp"),
+            path.join(homeDir, "Downloads"),
+        ].map((dir) => path.resolve(dir)))];
+}
+function listDiscoveredMboxCandidates(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    try {
+        const origin = classifyDiscoveredMboxOrigin(dir);
+        return fs.readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".mbox"))
+            .map((entry) => {
+            const candidatePath = path.join(dir, entry.name);
+            const stat = fs.statSync(candidatePath);
+            return {
+                path: candidatePath,
+                name: entry.name,
+                mtimeMs: stat.mtimeMs,
+                originKind: origin.originKind,
+                originLabel: origin.originLabel,
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeMboxDiscoveryText(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, " ")
+        .trim();
+}
+function tokenizeMboxDiscoveryHint(value) {
+    if (!value)
+        return [];
+    return normalizeMboxDiscoveryText(value)
+        .split(" ")
+        .filter((token) => token.length > 0);
+}
+function scoreDiscoveredMboxCandidate(fileName, mtimeMs, ownerEmail, source) {
+    const normalized = normalizeMboxDiscoveryText(fileName);
+    const ownerTokens = tokenizeMboxDiscoveryHint(ownerEmail);
+    const sourceTokens = tokenizeMboxDiscoveryHint(source);
+    const ownerScore = ownerTokens.reduce((score, token) => score + (normalized.includes(token) ? 50 : 0), 0);
+    const sourceScore = sourceTokens.reduce((score, token) => score + (normalized.includes(token) ? 20 : 0), 0);
+    const recencyScore = Math.floor(mtimeMs / 1000);
+    return ownerScore + sourceScore + recencyScore;
+}
+function rankDiscoveredMboxCandidates(candidates, ownerEmail, source) {
+    return candidates
+        .map((candidate) => ({
+        path: candidate.path,
+        score: scoreDiscoveredMboxCandidate(candidate.name, candidate.mtimeMs, ownerEmail, source),
+    }))
+        .sort((left, right) => right.score - left.score);
+}
+function discoverMailImportFilePath(input) {
+    const searchDirs = defaultMailImportDiscoveryDirs({
+        agentName: input.agentName,
+        repoRoot: input.repoRoot,
+        homeDir: input.homeDir,
+    });
+    const candidates = searchDirs.flatMap((dir) => listDiscoveredMboxCandidates(dir));
+    const ranked = rankDiscoveredMboxCandidates(candidates, input.ownerEmail, input.source);
+    if (ranked.length === 0) {
+        throw new Error(`could not discover an MBOX file in ${searchDirs.join(", ")}`);
+    }
+    const topScore = ranked[0].score;
+    const topCandidates = ranked.filter((candidate) => candidate.score === topScore);
+    if (topCandidates.length > 1) {
+        throw new Error(`multiple candidate MBOX files found: ${topCandidates.map((candidate) => candidate.path).join(", ")}`);
+    }
+    return topCandidates[0].path;
+}
+function summarizeAmbientImportCandidates(candidates, candidateLimit) {
+    const visibleCandidates = candidates.slice(0, candidateLimit);
+    const hiddenCount = Math.max(0, candidates.length - visibleCandidates.length);
+    const summary = visibleCandidates.length === 1
+        ? "recent MBOX archive ready for import"
+        : `${visibleCandidates.length} recent MBOX archives ready for import`;
+    const detailLines = [
+        "recent candidates:",
+        ...visibleCandidates.map((candidate) => `- [${candidate.originLabel}] ${candidate.path}`),
+        ...(hiddenCount > 0 ? [`- ...and ${hiddenCount} more recent archive${hiddenCount === 1 ? "" : "s"}`] : []),
+        "next: if one matches an outstanding mail backfill, run `ouro mail import-mbox --discover` with owner/source hints so Ouro can select the right archive or report ambiguity.",
+    ];
+    return {
+        summary,
+        detail: detailLines.join("\n"),
+        spec: {
+            fingerprint: recentImportFingerprint(candidates),
+            candidatePaths: visibleCandidates.map((candidate) => candidate.path),
+            candidateDescriptors: visibleCandidates.map((candidate) => ({
+                path: candidate.path,
+                originKind: candidate.originKind,
+                originLabel: candidate.originLabel,
+                modifiedAt: new Date(candidate.mtimeMs).toISOString(),
+            })),
+            newestCandidatePath: visibleCandidates[0]?.path ?? null,
+            newestCandidateMtime: visibleCandidates[0] ? new Date(visibleCandidates[0].mtimeMs).toISOString() : null,
+            newestCandidateOriginKind: visibleCandidates[0]?.originKind ?? null,
+            newestCandidateOriginLabel: visibleCandidates[0]?.originLabel ?? null,
+        },
+    };
+}
+function listAmbientMailImportOperations(input) {
+    const existingOperations = input.existingOperations ?? [];
+    const hasLiveImport = existingOperations.some((operation) => operation.kind === "mail.import-mbox"
+        && (operation.status === "queued" || operation.status === "running"));
+    if (hasLiveImport)
+        return [];
+    const nowMs = input.nowMs ?? Date.now();
+    const recentWindowMs = input.recentWindowMs ?? DEFAULT_RECENT_IMPORT_WINDOW_MS;
+    const candidateLimit = input.candidateLimit ?? DEFAULT_VISIBLE_IMPORT_CANDIDATE_LIMIT;
+    const recentCandidates = defaultMailImportDiscoveryDirs({
+        agentName: input.agentName,
+        repoRoot: input.repoRoot,
+        homeDir: input.homeDir,
+    })
+        .flatMap((dir) => listDiscoveredMboxCandidates(dir))
+        .filter((candidate) => (nowMs - candidate.mtimeMs) <= recentWindowMs)
+        .filter((candidate) => !existingOperations.some((operation) => candidateAlreadyCoveredByOperation(candidate, operation)))
+        .sort((left, right) => right.mtimeMs - left.mtimeMs);
+    if (recentCandidates.length === 0)
+        return [];
+    const newestCandidate = recentCandidates[0];
+    const rendered = summarizeAmbientImportCandidates(recentCandidates, candidateLimit);
+    return [{
+            schemaVersion: 1,
+            id: "ambient_mail_import_ready",
+            agentName: input.agentName,
+            kind: "mail.import-discovered",
+            title: "mail import ready",
+            status: "queued",
+            summary: rendered.summary,
+            detail: rendered.detail,
+            createdAt: new Date(newestCandidate.mtimeMs).toISOString(),
+            updatedAt: new Date(newestCandidate.mtimeMs).toISOString(),
+            spec: rendered.spec,
+        }];
+}
+function listVisibleBackgroundOperations(input) {
+    const limit = input.limit ?? DEFAULT_VISIBLE_BACKGROUND_OPERATION_LIMIT;
+    const persisted = (0, background_operations_1.listBackgroundOperations)({
+        agentName: input.agentName,
+        agentRoot: input.agentRoot,
+        limit,
+    });
+    const ambient = listAmbientMailImportOperations({
+        agentName: input.agentName,
+        agentRoot: input.agentRoot,
+        existingOperations: persisted,
+        repoRoot: input.repoRoot,
+        homeDir: input.homeDir,
+        nowMs: input.nowMs,
+        recentWindowMs: input.recentWindowMs,
+        candidateLimit: input.candidateLimit,
+    });
+    return [...persisted, ...ambient]
+        .sort(sortBackgroundOperationsNewestFirst)
+        .slice(0, limit);
+}

package/dist/heart/mailbox/mailbox-http-hooks.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMailboxHttpReadHooks = createMailboxHttpReadHooks;
+const path = __importStar(require("path"));
+const mailbox_read_1 = require("./mailbox-read");
+function createMailboxHttpReadHooks(options) {
+    const bundlesRoot = options.bundlesRoot;
+    const readOptions = bundlesRoot ? { bundlesRoot } : undefined;
+    const agentRoot = (agentName) => path.join(bundlesRoot ?? "", `${agentName}.ouro`);
+    return {
+        agentRoot,
+        readAgentSessions: options.readAgentSessions ?? ((agentName) => (0, mailbox_read_1.readSessionInventory)(agentName, readOptions)),
+        readAgentTranscript: options.readAgentTranscript ?? ((agentName, friendId, channel, key) => (0, mailbox_read_1.readSessionTranscript)(agentName, friendId, channel, key, readOptions)),
+        readAgentCoding: options.readAgentCoding ?? ((agentName) => (0, mailbox_read_1.readCodingDeep)(agentRoot(agentName))),
+        readAgentAttention: options.readAgentAttention ?? ((agentName) => (0, mailbox_read_1.readAttentionView)(agentName, readOptions)),
+        readAgentBridges: options.readAgentBridges ?? ((agentName) => (0, mailbox_read_1.readBridgeInventory)(agentRoot(agentName))),
+        readAgentNotes: options.readAgentNotes ?? ((agentName) => (0, mailbox_read_1.readNotesView)(agentRoot(agentName))),
+        readAgentFriends: options.readAgentFriends ?? ((agentName) => (0, mailbox_read_1.readFriendView)(agentName, readOptions)),
+        readAgentContinuity: options.readAgentContinuity ?? ((agentName) => (0, mailbox_read_1.readMailboxContinuity)(agentRoot(agentName), agentName)),
+        readAgentOrientation: options.readAgentOrientation ?? ((agentName) => (0, mailbox_read_1.readOrientationView)(agentRoot(agentName), agentName)),
+        readAgentObligations: options.readAgentObligations ?? ((agentName) => (0, mailbox_read_1.readObligationDetailView)(agentRoot(agentName))),
+        readAgentChanges: options.readAgentChanges ?? ((agentName) => (0, mailbox_read_1.readChangesView)(agentRoot(agentName))),
+        readAgentSelfFix: options.readAgentSelfFix ?? ((agentName) => (0, mailbox_read_1.readSelfFixView)(agentRoot(agentName))),
+        readAgentNoteDecisions: options.readAgentNoteDecisions ?? ((agentName) => (0, mailbox_read_1.readNoteDecisionView)(agentRoot(agentName))),
+        readAgentHabits: options.readAgentHabits ?? ((agentName) => (0, mailbox_read_1.readHabitView)(agentRoot(agentName))),
+        readAgentMail: options.readAgentMail ?? ((agentName) => (0, mailbox_read_1.readMailView)(agentName)),
+        readAgentMailMessage: options.readAgentMailMessage ?? ((agentName, messageId) => (0, mailbox_read_1.readMailMessageView)(agentName, messageId)),
+        readDaemonHealth: options.readDaemonHealth ?? (() => (0, mailbox_read_1.readDaemonHealthDeep)(options.healthPath)),
+        readLogs: options.readLogs ?? (() => (0, mailbox_read_1.readLogView)(options.logPath ?? null)),
+        readDeskPrefs: (agentName) => (0, mailbox_read_1.readDeskPrefs)(agentRoot(agentName)),
+        readNeedsMe: (agentName) => (0, mailbox_read_1.readNeedsMeView)(agentName, readOptions),
+    };
+}

package/dist/heart/mailbox/mailbox-http-response.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeJson = writeJson;
+function writeJson(response, statusCode, payload) {
+    response.writeHead(statusCode, { "content-type": "application/json; charset=utf-8" });
+    response.end(`${JSON.stringify(payload, null, 2)}\n`);
+}

package/dist/heart/mailbox/mailbox-http-routes.js

@@ -0,0 +1,246 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMailboxHttpRequestHandler = createMailboxHttpRequestHandler;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mailbox_http_response_1 = require("./mailbox-http-response");
+const mailbox_http_static_1 = require("./mailbox-http-static");
+function createMailboxHttpRequestHandler(options) {
+    const staticFiles = options.staticFiles ?? { resolveSpaDistDir: mailbox_http_static_1.resolveSpaDistDir, serveStaticFile: mailbox_http_static_1.serveStaticFile };
+    return (request, response) => {
+        let pathname = (0, mailbox_http_static_1.normalizeMailboxRequestPath)(request.url);
+        const origin = `http://${options.host}:${options.getPort()}`;
+        if (pathname.startsWith("/assets/")) {
+            const spaDir = staticFiles.resolveSpaDistDir();
+            if (spaDir) {
+                const assetPath = path.join(spaDir, pathname);
+                if (staticFiles.serveStaticFile(response, assetPath))
+                    return;
+            }
+            (0, mailbox_http_response_1.writeJson)(response, 404, { ok: false, error: "asset not found" });
+            return;
+        }
+        if (pathname === "/mailbox" || pathname === "/outlook") {
+            response.writeHead(301, { location: "/" });
+            response.end();
+            return;
+        }
+        pathname = (0, mailbox_http_static_1.normalizeLegacyMailboxApiPath)(pathname);
+        if (pathname === "/api/events") {
+            response.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", "connection": "keep-alive", "access-control-allow-origin": "*" });
+            response.write(":ok\n\n");
+            options.sse.add(response);
+            return;
+        }
+        if (pathname === "/api/machine") {
+            const machine = options.readMachineState();
+            const machineView = options.readMachineView?.({ origin, machine });
+            (0, mailbox_http_response_1.writeJson)(response, 200, machineView ?? machine);
+            return;
+        }
+        if (pathname === "/api/machine/health") {
+            const health = options.hooks.readDaemonHealth();
+            (0, mailbox_http_response_1.writeJson)(response, 200, health ?? { status: "unavailable" });
+            return;
+        }
+        if (pathname === "/api/machine/logs") {
+            (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readLogs());
+            return;
+        }
+        const agentMatch = /^\/api\/agents\/([^/]+)(?:\/(.+))?$/.exec(pathname);
+        if (agentMatch) {
+            void handleAgentRoute(request, response, {
+                agent: decodeURIComponent(agentMatch[1]),
+                surface: agentMatch[2] ?? null,
+                options,
+            }).catch((error) => {
+                (0, mailbox_http_response_1.writeJson)(response, 500, { ok: false, error: error instanceof Error ? error.message : String(error) });
+            });
+            return;
+        }
+        const spaDir = staticFiles.resolveSpaDistDir();
+        if (spaDir) {
+            if (staticFiles.serveStaticFile(response, path.join(spaDir, "index.html")))
+                return;
+        }
+        (0, mailbox_http_response_1.writeJson)(response, 404, { ok: false, error: `not found: ${pathname}` });
+    };
+}
+async function handleAgentRoute(request, response, context) {
+    const { agent, surface, options } = context;
+    if (!surface) {
+        const view = options.readAgentView?.(agent);
+        if (view) {
+            (0, mailbox_http_response_1.writeJson)(response, 200, view);
+            return;
+        }
+        const state = options.readAgentState(agent);
+        if (!state) {
+            (0, mailbox_http_response_1.writeJson)(response, 404, { ok: false, error: `unknown agent: ${agent}` });
+            return;
+        }
+        (0, mailbox_http_response_1.writeJson)(response, 200, state);
+        return;
+    }
+    if (surface === "sessions") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentSessions(agent));
+        return;
+    }
+    const transcriptMatch = /^sessions\/([^/]+)\/([^/]+)\/([^/]+)$/.exec(surface);
+    if (transcriptMatch) {
+        const friendId = decodeURIComponent(transcriptMatch[1]);
+        const channel = decodeURIComponent(transcriptMatch[2]);
+        const key = decodeURIComponent(transcriptMatch[3]);
+        const transcript = options.hooks.readAgentTranscript(agent, friendId, channel, key);
+        if (!transcript) {
+            (0, mailbox_http_response_1.writeJson)(response, 404, { ok: false, error: "session not found" });
+            return;
+        }
+        (0, mailbox_http_response_1.writeJson)(response, 200, transcript);
+        return;
+    }
+    if (surface === "coding") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentCoding(agent));
+        return;
+    }
+    if (surface === "attention") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentAttention(agent));
+        return;
+    }
+    if (surface === "bridges") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentBridges(agent));
+        return;
+    }
+    if (surface === "notes") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentNotes(agent));
+        return;
+    }
+    if (surface === "friends") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentFriends(agent));
+        return;
+    }
+    if (surface === "continuity") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentContinuity(agent));
+        return;
+    }
+    if (surface === "orientation") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentOrientation(agent));
+        return;
+    }
+    if (surface === "obligations") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentObligations(agent));
+        return;
+    }
+    if (surface === "changes") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentChanges(agent));
+        return;
+    }
+    if (surface === "self-fix") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentSelfFix(agent));
+        return;
+    }
+    if (surface === "note-decisions") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentNoteDecisions(agent));
+        return;
+    }
+    if (surface === "dismiss-obligation" && request.method === "POST") {
+        handleDismissObligation(request, response, options.hooks.agentRoot(agent));
+        return;
+    }
+    if (surface === "desk-prefs") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readDeskPrefs(agent));
+        return;
+    }
+    if (surface === "needs-me") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readNeedsMe(agent));
+        return;
+    }
+    if (surface === "habits") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, options.hooks.readAgentHabits(agent));
+        return;
+    }
+    if (surface === "mail") {
+        (0, mailbox_http_response_1.writeJson)(response, 200, await options.hooks.readAgentMail(agent));
+        return;
+    }
+    const mailMessageMatch = /^mail\/([^/]+)$/.exec(surface);
+    if (mailMessageMatch) {
+        const messageId = decodeURIComponent(mailMessageMatch[1]);
+        (0, mailbox_http_response_1.writeJson)(response, 200, await options.hooks.readAgentMailMessage(agent, messageId));
+        return;
+    }
+    if (surface === "inner-transcript") {
+        const transcript = options.hooks.readAgentTranscript(agent, "self", "inner", "dialog");
+        (0, mailbox_http_response_1.writeJson)(response, 200, transcript ?? { messageCount: 0, messages: [] });
+        return;
+    }
+    (0, mailbox_http_response_1.writeJson)(response, 404, { ok: false, error: `unknown agent surface: ${surface}` });
+}
+function handleDismissObligation(request, response, agentRoot) {
+    let body = "";
+    request.on("data", (chunk) => {
+        body += chunk;
+    });
+    request.on("end", () => {
+        try {
+            const { obligationId } = JSON.parse(body);
+            if (!obligationId) {
+                (0, mailbox_http_response_1.writeJson)(response, 400, { ok: false, error: "obligationId required" });
+                return;
+            }
+            const prefsPath = path.join(agentRoot, "state", "mailbox-prefs.json");
+            const legacyPrefsPath = path.join(agentRoot, "state", "outlook-prefs.json");
+            let prefs = {};
+            try {
+                const readPath = fs.existsSync(prefsPath) ? prefsPath : legacyPrefsPath;
+                prefs = JSON.parse(fs.readFileSync(readPath, "utf-8"));
+            }
+            catch {
+                // Missing or malformed prefs start from a clean preference object.
+            }
+            const dismissed = Array.isArray(prefs.dismissedObligations) ? prefs.dismissedObligations : [];
+            if (!dismissed.includes(obligationId))
+                dismissed.push(obligationId);
+            prefs.dismissedObligations = dismissed;
+            fs.mkdirSync(path.dirname(prefsPath), { recursive: true });
+            fs.writeFileSync(prefsPath, `${JSON.stringify(prefs, null, 2)}\n`, "utf-8");
+            (0, mailbox_http_response_1.writeJson)(response, 200, { ok: true, dismissed: dismissed.length });
+        }
+        catch (error) {
+            (0, mailbox_http_response_1.writeJson)(response, 500, { ok: false, error: String(error) });
+        }
+    });
+}