@aitne/daemon 0.1.8 → 0.1.10

package/dist/services/browser-history/automation/trace-store.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Trace store I/O — filesystem side of the Playwright screenshot capture
+ * surface.
+ *
+ * BROWSER_TASK_REDESIGN_PLAN.md §6.4. The disk layout
+ * (`${PA_DATA_DIR}/automation-traces/<id>/`) survived the Phase-6 rip-out
+ * of the workflow runner — the browser-task runtime writes its captured
+ * screenshots into the same tree, just keyed by `browser_task.id`
+ * instead of the old workflow uuid. This module exports the cron-side
+ * pruner; per-screenshot writes live inline in
+ * `browser-task-tools/server.ts` next to the §14.7 hostname-denylist
+ * retention check.
+ *
+ * Excluded from the 100% coverage gate (FS I/O around
+ * `fs/promises.readdir` / `stat` / `rm` is hard to exercise without
+ * process-level mocks that ESM blocks). The pure path arithmetic in
+ * `trace-store-paths.ts` IS in the covered set so the
+ * directory-traversal defence is locked in by tests.
+ */
+/** Days to retain trace assets before the daily cleanup deletes them. */
+export declare const TRACE_RETENTION_DAYS = 14;
+/**
+ * Delete every per-task trace directory whose latest mtime is older
+ * than `cutoffEpochMs`. Returns the count of pruned directories.
+ *
+ * Errors on individual entries are logged and skipped — the cron MUST
+ * not fail outright because one orphaned dir refuses to delete.
+ */
+export declare function pruneTraceDirectory(paDataDir: string, cutoffEpochMs: number): Promise<number>;

package/dist/services/browser-history/automation/trace-store.js

@@ -0,0 +1,63 @@
+/**
+ * Trace store I/O — filesystem side of the Playwright screenshot capture
+ * surface.
+ *
+ * BROWSER_TASK_REDESIGN_PLAN.md §6.4. The disk layout
+ * (`${PA_DATA_DIR}/automation-traces/<id>/`) survived the Phase-6 rip-out
+ * of the workflow runner — the browser-task runtime writes its captured
+ * screenshots into the same tree, just keyed by `browser_task.id`
+ * instead of the old workflow uuid. This module exports the cron-side
+ * pruner; per-screenshot writes live inline in
+ * `browser-task-tools/server.ts` next to the §14.7 hostname-denylist
+ * retention check.
+ *
+ * Excluded from the 100% coverage gate (FS I/O around
+ * `fs/promises.readdir` / `stat` / `rm` is hard to exercise without
+ * process-level mocks that ESM blocks). The pure path arithmetic in
+ * `trace-store-paths.ts` IS in the covered set so the
+ * directory-traversal defence is locked in by tests.
+ */
+import { readdir, rm, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { createLogger } from "../../../logging.js";
+import { tracesRootDir } from "./trace-store-paths.js";
+const logger = createLogger("browser-automation-trace-store");
+/** Days to retain trace assets before the daily cleanup deletes them. */
+export const TRACE_RETENTION_DAYS = 14;
+/**
+ * Delete every per-task trace directory whose latest mtime is older
+ * than `cutoffEpochMs`. Returns the count of pruned directories.
+ *
+ * Errors on individual entries are logged and skipped — the cron MUST
+ * not fail outright because one orphaned dir refuses to delete.
+ */
+export async function pruneTraceDirectory(paDataDir, cutoffEpochMs) {
+    const root = tracesRootDir(paDataDir);
+    let entries;
+    try {
+        entries = await readdir(root);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return 0;
+        logger.warn({ err }, "pruneTraceDirectory readdir failed");
+        return 0;
+    }
+    let pruned = 0;
+    for (const entry of entries) {
+        const dir = join(root, entry);
+        try {
+            const stats = await stat(dir);
+            if (!stats.isDirectory())
+                continue;
+            if (stats.mtimeMs >= cutoffEpochMs)
+                continue;
+            await rm(dir, { recursive: true, force: true });
+            pruned += 1;
+        }
+        catch (err) {
+            logger.warn({ err, dir }, "pruneTraceDirectory entry skip");
+        }
+    }
+    return pruned;
+}

package/dist/services/browser-history/cleanup-interests-reflection.d.ts

@@ -0,0 +1,39 @@
+import type Database from "better-sqlite3";
+import type { AgentWriteTracker } from "../../safety/agent-write-tracker.js";
+export interface CleanupOptions {
+    /**
+     * If true (default), also delete `user/research-themes.md`. The file
+     * is wholly daemon-owned (`owner: aitne-browser-history` in
+     * frontmatter), so a delete is the intuitive purge — `cleanup` is
+     * the user saying "remove the auto-generated content". When false,
+     * the file is retained (the dashboard surfaces this as
+     * "Remove the auto-blocks but keep the snapshot file").
+     */
+    readonly alsoDeleteResearchThemesFile?: boolean;
+    /**
+     * Provenance tag for the audit row. The HTTP route passes
+     * `"dashboard"`; tests pass `"test"`. There is no scheduler-trigger
+     * path for cleanup — the feature has no per-feature toggle, so
+     * cron-driven purges would be a contradiction (§13).
+     */
+    readonly trigger?: "dashboard" | "test";
+    /**
+     * FS-watcher attribution channel. Marked on every file we strip
+     * blocks from AND on the `user/research-themes.md` delete (path-only
+     * mode for the delete since post-unlink there is no content to hash).
+     * Without it the cleanup's writes would be observed as user edits —
+     * the inverse of the operator's intent (a one-shot purge should not
+     * read like fresh user activity to the morning routine / hourly
+     * check signal floor).
+     */
+    readonly writeTracker?: AgentWriteTracker;
+}
+export interface CleanupResult {
+    /** Number of `aitne:browser-interests v1` blocks stripped, summed across all files. */
+    blocksRemoved: number;
+    /** Relative paths (POSIX) of files whose contents changed or were deleted. */
+    filesAffected: string[];
+    /** True iff `user/research-themes.md` was deleted in this pass. False if it was absent or retention was requested. */
+    researchThemesDeleted: boolean;
+}
+export declare function cleanupInterestsReflection(db: Database.Database, contextDir: string, options?: CleanupOptions): CleanupResult;

package/dist/services/browser-history/cleanup-interests-reflection.js

@@ -0,0 +1,204 @@
+import { existsSync, readFileSync, readdirSync, unlinkSync, } from "node:fs";
+import { join, relative } from "node:path";
+import { writeFileAtomically } from "../../core/atomic-write.js";
+import { deleteRuntimeState } from "../../db/runtime-state.js";
+import { createLogger } from "../../logging.js";
+import { acquireInterestsReflectionLock } from "./interests-reflection-lock.js";
+import { stripAllAutoBlocks } from "./pipeline/interests-block.js";
+import { RUNTIME_STATE_LAST_RUN_AT_KEY, RUNTIME_STATE_LAST_RUN_TARGETS_KEY, } from "./refresh-interests-reflection.js";
+/**
+ * WEEKLY_INTERESTS_REFLECTION_PLAN.md §10.3.1 — bulk-purge counterpart
+ * of `refreshInterestsReflection`. Invoked exclusively from the
+ * dashboard `POST /api/browser-history/cleanup-interests-reflection`
+ * (Approve tier; bearer-token required) and from tests; no skill or
+ * scheduler path reaches this helper.
+ *
+ * Four-step purge per §10.3.1:
+ *
+ *   1. Strip every `<!-- BEGIN aitne:browser-interests v1 … --> …
+ *      <!-- END aitne:browser-interests v1 … -->` block from
+ *      `identity/profile.md`, `identity/_index.md`, and every `projects/*.md`.
+ *   2. If `alsoDeleteResearchThemesFile` is true (default), delete
+ *      `user/research-themes.md` — the wholly-daemon-owned file from
+ *      Mode B writes.
+ *   3. Clear the two `runtime_state` markers the refresh helper writes
+ *      (`weekly_interests_last_run_at` / `..._targets`).
+ *   4. Emit one `agent_actions(action_type='browser_interests_
+ *      reflection_cleanup', …)` row carrying the structural detail the
+ *      dashboard surfaces ("blocksRemoved / filesAffected /
+ *      researchThemesDeleted").
+ *
+ * Idempotent by construction: a re-run on already-cleaned files
+ * removes zero blocks, leaves `runtime_state` queries returning null,
+ * and produces the same return shape. The cleanup is a *one-shot
+ * purge*, not a feature toggle — the next `routine.weekly_review`
+ * re-creates fresh content from scratch as long as the upstream
+ * `browser-history` integration is still enabled (§13).
+ */
+const logger = createLogger("cleanup-interests-reflection");
+export function cleanupInterestsReflection(db, contextDir, options = {}) {
+    const alsoDeleteThemes = options.alsoDeleteResearchThemesFile ?? true;
+    const trigger = options.trigger ?? "dashboard";
+    const writeTracker = options.writeTracker;
+    // Same courtesy mutex as the refresh helper. Contention is a
+    // surface-level error the caller decides how to handle (HTTP 409
+    // for the dashboard route). Held until the helper returns (try/
+    // finally below) so a concurrent refresh cannot interleave block-
+    // strip and block-write on the same files, and so a future
+    // refactor introducing a throw cannot leak the lock.
+    const release = acquireInterestsReflectionLock(`cleanup:${trigger}`);
+    try {
+        return runCleanup(db, contextDir, trigger, alsoDeleteThemes, writeTracker);
+    }
+    finally {
+        release();
+    }
+}
+function runCleanup(db, contextDir, trigger, alsoDeleteThemes, writeTracker) {
+    let blocksRemoved = 0;
+    const filesAffected = [];
+    // 1. user/profile.md
+    blocksRemoved += stripBlocksFromFile(contextDir, join(contextDir, "identity", "profile.md"), filesAffected, writeTracker);
+    // 2. user/_index.md
+    blocksRemoved += stripBlocksFromFile(contextDir, join(contextDir, "identity", "_index.md"), filesAffected, writeTracker);
+    // 3. every projects/*.md (only the .md files at the top level —
+    //    no recursion into subdirectories; the matcher only writes to
+    //    top-level project files, so a recursive scan would expand the
+    //    blast radius without matching the writer).
+    const projectsDir = join(contextDir, "plans", "projects");
+    if (existsSync(projectsDir)) {
+        let entries = [];
+        try {
+            entries = readdirSync(projectsDir);
+        }
+        catch (err) {
+            logger.warn({ err, projectsDir }, "Failed to enumerate projects/ during cleanup; skipping project annotations");
+            entries = [];
+        }
+        for (const name of entries) {
+            if (!name.endsWith(".md"))
+                continue;
+            const fullPath = join(projectsDir, name);
+            blocksRemoved += stripBlocksFromFile(contextDir, fullPath, filesAffected, writeTracker);
+        }
+    }
+    // 4. Optional: delete user/research-themes.md
+    const themesPath = join(contextDir, "identity", "research-themes.md");
+    let researchThemesDeleted = false;
+    if (alsoDeleteThemes && existsSync(themesPath)) {
+        // Mark path-only (no content to hash post-unlink). The tracker's
+        // path-only entry causes `isMarked(themesPath, …)` to return true
+        // for any observation on the path within the TTL — including the
+        // chokidar `unlink` event. Roll back on failure so a missed delete
+        // does not suppress a later legitimate user edit on the same path.
+        writeTracker?.markWriting(themesPath);
+        try {
+            unlinkSync(themesPath);
+            researchThemesDeleted = true;
+            filesAffected.push(relativePosix(contextDir, themesPath));
+        }
+        catch (err) {
+            writeTracker?.unmark(themesPath);
+            // Deletion failure is non-fatal — the block-strip pass is the
+            // load-bearing surface (the user-injected `<user>` context comes
+            // from profile.md, not research-themes.md). Log loudly and
+            // continue so the audit row still records the partial purge.
+            logger.error({ err, themesPath }, "Failed to delete research-themes.md during cleanup");
+        }
+    }
+    // 5. Clear runtime_state markers regardless of file outcomes so a
+    //    fresh weekly_review tick starts from a clean slate.
+    try {
+        deleteRuntimeState(db, RUNTIME_STATE_LAST_RUN_AT_KEY);
+        deleteRuntimeState(db, RUNTIME_STATE_LAST_RUN_TARGETS_KEY);
+    }
+    catch (err) {
+        logger.error({ err }, "Failed to clear runtime_state markers during cleanup");
+    }
+    const result = {
+        blocksRemoved,
+        filesAffected,
+        researchThemesDeleted,
+    };
+    emitAuditRow(db, result, trigger);
+    logger.info({
+        trigger,
+        blocksRemoved: result.blocksRemoved,
+        filesAffected: result.filesAffected.length,
+        researchThemesDeleted: result.researchThemesDeleted,
+    }, "Weekly interests reflection cleanup applied");
+    return result;
+}
+/**
+ * Strip every `aitne:browser-interests v1` block from `fullPath`.
+ * Returns the count removed; mutates `filesAffected` (push of the
+ * relative path) only if any content changed. A missing file is a
+ * no-op, matching the idempotency contract.
+ *
+ * Block detection is delegated to `stripAllAutoBlocks` so the BEGIN/END
+ * regex shape lives in exactly one place (`pipeline/interests-block.ts`).
+ * The local-only concern here is the post-strip tidy (collapse 3+
+ * newline runs, normalise the trailing newline) which is intentionally
+ * more aggressive than the shared helper's minimal trailing-newline
+ * preservation — repeated cleanup passes should not accumulate
+ * blank-line drift in the file.
+ */
+function stripBlocksFromFile(contextDir, fullPath, filesAffected, writeTracker) {
+    if (!existsSync(fullPath))
+        return 0;
+    let original;
+    try {
+        original = readFileSync(fullPath, "utf-8");
+    }
+    catch (err) {
+        logger.warn({ err, fullPath }, "Failed to read file during cleanup; skipping");
+        return 0;
+    }
+    const { content: stripped, blocksRemoved } = stripAllAutoBlocks(original);
+    if (blocksRemoved === 0)
+        return 0;
+    // Collapse any trailing whitespace runs created by the substitution
+    // so the file does not accumulate blank-line growth across repeated
+    // cleanup invocations. Keep at most one trailing newline.
+    const tidied = stripped.replace(/\n{3,}/g, "\n\n").replace(/[\s\n]+$/, "\n");
+    // Mark BEFORE the rename so chokidar's debounced `change` event is
+    // classified as agent-originated. Roll back on failure so a stale
+    // mark does not suppress a later legitimate user edit (C2 pattern,
+    // same as roadmap-maintenance.ts and core/context/write.ts).
+    writeTracker?.markWriting(fullPath, tidied);
+    try {
+        writeFileAtomically(fullPath, tidied);
+        filesAffected.push(relativePosix(contextDir, fullPath));
+    }
+    catch (err) {
+        writeTracker?.unmark(fullPath);
+        logger.error({ err, fullPath }, "Failed to write stripped content during cleanup");
+        return 0;
+    }
+    return blocksRemoved;
+}
+function relativePosix(contextDir, fullPath) {
+    return relative(contextDir, fullPath).split("\\").join("/");
+}
+function emitAuditRow(db, result, trigger) {
+    try {
+        db.prepare(`INSERT INTO agent_actions
+         (action_type, trigger, result, detail, completed_at, source_kind, metadata)
+       VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP, ?, ?)`).run("browser_interests_reflection_cleanup", `weekly_interests_cleanup:${trigger}`, "success", JSON.stringify({
+            trigger,
+            blocks_removed: result.blocksRemoved,
+            files_affected: result.filesAffected,
+            research_themes_deleted: result.researchThemesDeleted,
+        }), "manual", 
+        // Explicit `metadata: '{}'`. Same rationale as the refresh helper:
+        // daemon-write rows leave the agent-self-report side-channel
+        // empty per the `agent_actions` schema comment.
+        "{}");
+    }
+    catch (err) {
+        // Mirror the refresh helper's posture: an audit-row failure must
+        // not abort the purge — file writes are the load-bearing
+        // side-effect. Log loudly so an operator notices the audit gap.
+        logger.error({ err }, "Failed to write cleanup audit row");
+    }
+}

package/dist/services/browser-history/detectors/atlas.d.ts

@@ -0,0 +1,2 @@
+import type { HostProfile } from "../types.js";
+export declare function detectAtlas(host: HostProfile, cacheRoot: string): Promise<import("../types.js").BrowserDetectionResult>;

package/dist/services/browser-history/detectors/atlas.js

@@ -0,0 +1,4 @@
+import { detectChromiumBrowser } from "./chromium.js";
+export function detectAtlas(host, cacheRoot) {
+    return detectChromiumBrowser("atlas", host, cacheRoot);
+}

package/dist/services/browser-history/detectors/chrome.d.ts

@@ -0,0 +1,2 @@
+import type { HostProfile } from "../types.js";
+export declare function detectChrome(host: HostProfile, cacheRoot: string): Promise<import("../types.js").BrowserDetectionResult>;

package/dist/services/browser-history/detectors/chrome.js

@@ -0,0 +1,4 @@
+import { detectChromiumBrowser } from "./chromium.js";
+export function detectChrome(host, cacheRoot) {
+    return detectChromiumBrowser("chrome", host, cacheRoot);
+}

package/dist/services/browser-history/detectors/chromium.d.ts

@@ -0,0 +1,2 @@
+import type { BrowserDetectionResult, ChromiumBrowserKey, HostProfile } from "../types.js";
+export declare function detectChromiumBrowser(browser: ChromiumBrowserKey, host: HostProfile, cacheRoot: string): Promise<BrowserDetectionResult>;

package/dist/services/browser-history/detectors/chromium.js

@@ -0,0 +1,193 @@
+import { access, readdir, readFile, stat } from "node:fs/promises";
+import { constants, existsSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { createBrowserHistorySnapshot } from "../readers/snapshot.js";
+import { assertChromiumHistorySchema } from "../readers/chromium-reader.js";
+import { freshestHistoryMtimeMs } from "../history-mtime.js";
+async function canRead(path) {
+    try {
+        await access(path, constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readLocalState(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function isSignedIn(localState, profileName) {
+    const profile = localState?.profile?.info_cache?.[profileName];
+    return !!(profile?.user_name
+        || localState?.signin?.allowed_username
+        || localState?.signin?.signed_in_to);
+}
+async function enumerateProfileNames(root, localState) {
+    const fromLocalState = Object.keys(localState?.profile?.info_cache ?? {});
+    const names = new Set(fromLocalState);
+    try {
+        const entries = await readdir(root, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name === "Default"
+                || /^Profile \d+$/.test(entry.name)
+                || existsSync(join(root, entry.name, "History"))) {
+                names.add(entry.name);
+            }
+        }
+    }
+    catch {
+        // Caller handles the root-level access failure.
+    }
+    return [...names];
+}
+function detectStatusFromProfiles(profiles, hadSchemaError) {
+    if (profiles.length === 0)
+        return hadSchemaError ? "error" : "not_installed";
+    if (profiles.some((profile) => profile.signedIn)) {
+        const now = Date.now();
+        const stale = profiles.every((profile) => profile.lastHistoryMtimeMs !== null
+            && now - profile.lastHistoryMtimeMs > 24 * 60 * 60 * 1000);
+        return stale ? "available_sync_broken" : "available";
+    }
+    return "available_no_sync";
+}
+async function validateHistory(historyPath, cacheRoot) {
+    const snapshot = await createBrowserHistorySnapshot(historyPath, cacheRoot);
+    try {
+        assertChromiumHistorySchema(snapshot.mainPath);
+        return true;
+    }
+    finally {
+        await snapshot.cleanup();
+    }
+}
+export async function detectChromiumBrowser(browser, host, cacheRoot) {
+    let sawPermissionDenied = false;
+    let sawSchemaError = false;
+    const profiles = [];
+    for (const root of host.profileRootCandidatesFor(browser)) {
+        if (!existsSync(root))
+            continue;
+        if (!(await canRead(root))) {
+            sawPermissionDenied = true;
+            continue;
+        }
+        const localStatePath = join(root, "Local State");
+        const localState = await readLocalState(localStatePath);
+        const names = await enumerateProfileNames(root, localState);
+        for (const profileName of names) {
+            const historyPath = join(root, profileName, "History");
+            if (!existsSync(historyPath))
+                continue;
+            if (!(await canRead(historyPath))) {
+                sawPermissionDenied = true;
+                continue;
+            }
+            let historyStat;
+            try {
+                historyStat = await stat(historyPath);
+            }
+            catch {
+                continue;
+            }
+            if (!historyStat.isFile() || historyStat.size === 0)
+                continue;
+            try {
+                await validateHistory(historyPath, cacheRoot);
+            }
+            catch {
+                sawSchemaError = true;
+                continue;
+            }
+            profiles.push({
+                browser,
+                profileName,
+                userDataDir: root,
+                historyPath,
+                localStatePath,
+                signedIn: isSignedIn(localState, profileName),
+                canonical: true,
+                // Family-aware mtime — see history-mtime.ts. Stat'ing only
+                // `History` misses WAL writes and rollback-journal transactions
+                // and would mark actively-used profiles as `available_sync_broken`.
+                lastHistoryMtimeMs: (await freshestHistoryMtimeMs(historyPath)) ?? historyStat.mtimeMs,
+            });
+        }
+    }
+    // Atlas stores real browsing under per-account `user-<id>__<uuid>`
+    // profile dirs. The `Default` (and `Profile N`) dirs are vestigial stubs
+    // created on first launch and abandoned the moment the user signs into
+    // their ChatGPT account; the stub's `History` then freezes forever. The
+    // generic enumeration above picks up BOTH the stub and the live account
+    // profile (the latter via the `existsSync(History)` clause), so the
+    // lifecycle supervisor ends up tracking the frozen stub too — emitting a
+    // perpetual `browser_lifecycle.atlas` / `sync_unresponsive` failure every
+    // tick because the stub's mtime never advances. Drop the stubs whenever a
+    // live account profile is present so only real profiles are reported.
+    if (browser === "atlas") {
+        const accountProfiles = profiles.filter((profile) => profile.profileName.startsWith("user-"));
+        if (accountProfiles.length > 0 && accountProfiles.length !== profiles.length) {
+            profiles.splice(0, profiles.length, ...accountProfiles);
+        }
+    }
+    if (profiles.length === 0 && browser === "atlas") {
+        const atlasProfiles = await detectAtlasFallback(host, cacheRoot);
+        profiles.push(...atlasProfiles);
+    }
+    if (profiles.length === 0 && sawPermissionDenied) {
+        return { browser, status: "permission_denied", profiles };
+    }
+    return {
+        browser,
+        status: detectStatusFromProfiles(profiles, sawSchemaError),
+        profiles,
+        nonCanonicalLayout: profiles.some((profile) => !profile.canonical),
+    };
+}
+async function detectAtlasFallback(host, cacheRoot) {
+    const found = [];
+    for (const root of host.profileRootCandidatesFor("atlas")) {
+        if (!existsSync(root))
+            continue;
+        let entries;
+        try {
+            entries = await readdir(root, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory() || !entry.name.startsWith("user-"))
+                continue;
+            const candidate = join(root, entry.name, "History");
+            if (!existsSync(candidate))
+                continue;
+            try {
+                const historyStat = await stat(candidate);
+                if (!historyStat.isFile() || historyStat.size === 0)
+                    continue;
+                await validateHistory(candidate, cacheRoot);
+                found.push({
+                    browser: "atlas",
+                    profileName: basename(dirname(candidate)),
+                    userDataDir: dirname(candidate),
+                    historyPath: candidate,
+                    signedIn: false,
+                    canonical: false,
+                    lastHistoryMtimeMs: (await freshestHistoryMtimeMs(candidate)) ?? historyStat.mtimeMs,
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return found;
+}

package/dist/services/browser-history/detectors/comet.d.ts

@@ -0,0 +1,2 @@
+import type { HostProfile } from "../types.js";
+export declare function detectComet(host: HostProfile, cacheRoot: string): Promise<import("../types.js").BrowserDetectionResult>;

package/dist/services/browser-history/detectors/comet.js

@@ -0,0 +1,4 @@
+import { detectChromiumBrowser } from "./chromium.js";
+export function detectComet(host, cacheRoot) {
+    return detectChromiumBrowser("comet", host, cacheRoot);
+}

package/dist/services/browser-history/detectors/registry.d.ts

@@ -0,0 +1,15 @@
+import type { BrowserHistoryBrowserKey, BrowserHistoryCapabilities } from "@aitne/shared";
+import type { AgentConfig } from "../../../config.js";
+import { readIntegrations } from "../../../db/integrations-store.js";
+import type { BrowserDetectionResult, HostProfile } from "../types.js";
+export declare function browserHistoryCacheRoot(dataDir: string): string;
+export declare function computeBrowserHistoryIngestEnabled(db: Parameters<typeof readIntegrations>[0], config: Pick<AgentConfig, "browserHistoryConsentAccepted" | "browserHistoryBrowserOverrides">, results: readonly BrowserDetectionResult[]): BrowserHistoryBrowserKey[];
+export declare function serializeBrowserHistoryCapabilities(detectedAt: string, results: readonly BrowserDetectionResult[], ingestEnabled: BrowserHistoryBrowserKey[]): BrowserHistoryCapabilities;
+export declare function detectBrowserHistoryCapabilities(params: {
+    db: Parameters<typeof readIntegrations>[0];
+    config: AgentConfig;
+    host: HostProfile;
+}): Promise<{
+    capabilities: BrowserHistoryCapabilities;
+    results: BrowserDetectionResult[];
+}>;

package/dist/services/browser-history/detectors/registry.js

@@ -0,0 +1,82 @@
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { readIntegrations } from "../../../db/integrations-store.js";
+import { detectChromiumBrowser } from "./chromium.js";
+import { detectChrome } from "./chrome.js";
+import { detectComet } from "./comet.js";
+import { detectAtlas } from "./atlas.js";
+const ALL_BROWSERS = [
+    "chrome",
+    "chromium",
+    "edge",
+    "brave",
+    "comet",
+    "atlas",
+];
+function isReadableStatus(status) {
+    return status === "available"
+        || status === "available_no_sync"
+        || status === "available_sync_broken";
+}
+export function browserHistoryCacheRoot(dataDir) {
+    return join(dataDir, "cache", "browser-history");
+}
+export function computeBrowserHistoryIngestEnabled(db, config, results) {
+    const integrations = readIntegrations(db);
+    if (!config.browserHistoryConsentAccepted
+        || integrations.browser_history?.mode !== "direct") {
+        return [];
+    }
+    const enabled = [];
+    for (const result of results) {
+        const override = config.browserHistoryBrowserOverrides[result.browser] ?? "auto";
+        if (override === "forced-off")
+            continue;
+        if (override === "forced-on" || isReadableStatus(result.status)) {
+            enabled.push(result.browser);
+        }
+    }
+    return enabled;
+}
+export function serializeBrowserHistoryCapabilities(detectedAt, results, ingestEnabled) {
+    const browsers = Object.fromEntries(ALL_BROWSERS.map((browser) => {
+        const result = results.find((entry) => entry.browser === browser);
+        return [browser, result?.status ?? "not_installed"];
+    }));
+    const details = Object.fromEntries(results.map((result) => {
+        const mtimes = result.profiles
+            .map((profile) => profile.lastHistoryMtimeMs)
+            .filter((value) => value !== null);
+        return [
+            result.browser,
+            {
+                status: result.status,
+                profileCount: result.profiles.length,
+                readableProfiles: result.profiles.length,
+                signedInProfiles: result.profiles.filter((profile) => profile.signedIn).length,
+                lastHistoryMtimeMs: mtimes.length > 0 ? Math.max(...mtimes) : null,
+                nonCanonicalLayout: result.nonCanonicalLayout ?? false,
+                message: result.error ?? null,
+            },
+        ];
+    }));
+    return { detectedAt, browsers, ingestEnabled, details };
+}
+export async function detectBrowserHistoryCapabilities(params) {
+    const cacheRoot = browserHistoryCacheRoot(params.config.dataDir);
+    await mkdir(cacheRoot, { recursive: true, mode: 0o700 });
+    const detectorCalls = [
+        detectChrome(params.host, cacheRoot),
+        detectChromiumBrowser("chromium", params.host, cacheRoot),
+        detectChromiumBrowser("edge", params.host, cacheRoot),
+        detectChromiumBrowser("brave", params.host, cacheRoot),
+        detectComet(params.host, cacheRoot),
+        detectAtlas(params.host, cacheRoot),
+    ];
+    const results = await Promise.all(detectorCalls);
+    const ingestEnabled = computeBrowserHistoryIngestEnabled(params.db, params.config, results);
+    return {
+        capabilities: serializeBrowserHistoryCapabilities(new Date().toISOString(), results, ingestEnabled),
+        results,
+    };
+}