@aitne/daemon 0.1.8 → 0.1.9

package/dist/messaging/purchase-system-message-sender.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Phase B-4 purchase-confirmation DM dispatcher.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.3 / §17.7 / §13 step 52.
+ *
+ * This module is the "sendSystemMessage" surface §17.7 specifies. The
+ * agent cannot reach it: every exported method requires the unforgeable
+ * capability symbol minted in `purchase-handler.ts`. The daemon
+ * bootstrap path acquires the symbol via the dedicated getter and
+ * passes it into both the handler and this sender; no other code path
+ * can mint it.
+ *
+ * The classifier `classifyPurchaseConfirmationTemplate` defends the
+ * other direction: any agent-tool-originated outbound message
+ * containing the reserved structural markers ("Aitne purchase
+ * confirmation", "[purchase-verify:", "Approved on …") is refused by
+ * the agent-facing outbound chokepoint
+ * (`safety/outbound-purchase-guard.ts`). Together, the two halves
+ * close the structural-anti-spoofing surface.
+ */
+import { type MessageHub } from "../adapters/message-hub.js";
+import { type IngestOutboundImage } from "./browser-task-screenshot-attachment.js";
+import { type PurchaseSystemMessageSender } from "../services/browser-history/automation/purchase-handler.js";
+import type { PurchaseCancelReason } from "../db/browser-automation-purchase-tokens-store.js";
+export interface CreatePurchaseSenderDeps {
+    messageHub: MessageHub;
+    /** Daemon data directory (`PA_DATA_DIR`). Resolves the pre-confirm
+     *  screenshot key to its on-disk trace file so the bytes are attached
+     *  inline (messaging native upload / dashboard ingest) rather than sent
+     *  as a loopback URL the user cannot reach. */
+    paDataDir?: string;
+    /** Ingest hook for the `dashboard` platform — see
+     *  `browser-task-screenshot-attachment.ts`. */
+    ingestOutboundImage?: IngestOutboundImage;
+    /** Override for tests; production uses Date.now. */
+    nowFn?: () => number;
+}
+/**
+ * Construct the credentialed sender. The factory grabs the capability
+ * via the private getter — there's no other way to obtain one, which is
+ * what makes the surface "module-level credential" §17.7 requires.
+ *
+ * Every method asserts the incoming `capability` matches the module's
+ * minted symbol. A mismatched / forged capability throws; the throw is
+ * the structural enforcement of "agent tools cannot mint this".
+ */
+export declare function createPurchaseSystemMessageSender(deps: CreatePurchaseSenderDeps): PurchaseSystemMessageSender;
+/**
+ * Convenience helper for the cancellation follow-up's audit message —
+ * exported so other daemon-internal cancel paths (the supervisor's
+ * orphan sweep, the dashboard's "cancel pending" action) format the
+ * cancel reason identically. Pure — no I/O.
+ */
+export declare function describeCancelReason(reason: PurchaseCancelReason): string;

package/dist/messaging/purchase-system-message-sender.js

@@ -0,0 +1,213 @@
+/**
+ * Phase B-4 purchase-confirmation DM dispatcher.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.3 / §17.7 / §13 step 52.
+ *
+ * This module is the "sendSystemMessage" surface §17.7 specifies. The
+ * agent cannot reach it: every exported method requires the unforgeable
+ * capability symbol minted in `purchase-handler.ts`. The daemon
+ * bootstrap path acquires the symbol via the dedicated getter and
+ * passes it into both the handler and this sender; no other code path
+ * can mint it.
+ *
+ * The classifier `classifyPurchaseConfirmationTemplate` defends the
+ * other direction: any agent-tool-originated outbound message
+ * containing the reserved structural markers ("Aitne purchase
+ * confirmation", "[purchase-verify:", "Approved on …") is refused by
+ * the agent-facing outbound chokepoint
+ * (`safety/outbound-purchase-guard.ts`). Together, the two halves
+ * close the structural-anti-spoofing surface.
+ */
+import { createLogger } from "../logging.js";
+import { MessageDeliveryError, } from "../adapters/message-hub.js";
+import { resolveScreenshotAttachment, } from "./browser-task-screenshot-attachment.js";
+import { parseChannelRef, } from "../db/browser-automation-purchase-primary-channels-store.js";
+import { __aitneB4_getPurchaseHandlerCapability, } from "../services/browser-history/automation/purchase-handler.js";
+import { PURCHASE_CONFIRMATION_HEADER, redactToken, } from "../services/browser-history/automation/purchase-tokens.js";
+const logger = createLogger("purchase-system-message-sender");
+/** ISO-4217 currencies with 0 decimal places (subset; mirrors the
+ *  purchase-handler's formatter). */
+const ZERO_DECIMAL_CURRENCIES = new Set([
+    "JPY", "KRW", "VND", "CLP", "ISK", "PYG", "RWF", "UGX",
+    "BIF", "DJF", "GNF", "KMF", "MGA", "XAF", "XOF", "XPF",
+]);
+function formatAmount(amountMinor, currency) {
+    const code = currency.toUpperCase();
+    const zeroDecimal = ZERO_DECIMAL_CURRENCIES.has(code);
+    const major = zeroDecimal
+        ? amountMinor.toLocaleString("en-US")
+        : (amountMinor / 100).toLocaleString("en-US", {
+            minimumFractionDigits: 2,
+            maximumFractionDigits: 2,
+        });
+    return code === "JPY" ? `¥${major}` : `${code} ${major}`;
+}
+function formatExpiry(expiresAtMs, nowMs) {
+    const remainingMs = Math.max(0, expiresAtMs - nowMs);
+    const minutes = Math.floor(remainingMs / 60000);
+    const seconds = Math.floor((remainingMs % 60000) / 1000);
+    return `${minutes}m ${seconds.toString().padStart(2, "0")}s`;
+}
+/**
+ * Construct the credentialed sender. The factory grabs the capability
+ * via the private getter — there's no other way to obtain one, which is
+ * what makes the surface "module-level credential" §17.7 requires.
+ *
+ * Every method asserts the incoming `capability` matches the module's
+ * minted symbol. A mismatched / forged capability throws; the throw is
+ * the structural enforcement of "agent tools cannot mint this".
+ */
+export function createPurchaseSystemMessageSender(deps) {
+    const expected = __aitneB4_getPurchaseHandlerCapability();
+    const now = deps.nowFn ?? (() => Date.now());
+    const paDataDir = deps.paDataDir ?? null;
+    function assertCapability(received) {
+        if (received !== expected) {
+            throw new Error("purchase-system-message-sender: capability mismatch — refusing dispatch");
+        }
+    }
+    // The pre-confirm screenshot is delivered as actual image bytes — native
+    // upload for messaging adapters, AttachmentStore ingest for the dashboard —
+    // never a loopback trace URL (a phone cannot reach it; a raw dashboard
+    // <img> cannot authenticate it). See `browser-task-screenshot-attachment`.
+    async function dispatch(ref, text, screenshotKey) {
+        const parsed = parseChannelRef(ref);
+        if (!parsed) {
+            return { ok: false, reason: "invalid_ref" };
+        }
+        let attachments;
+        if (screenshotKey) {
+            const att = await resolveScreenshotAttachment({
+                platform: parsed.platform,
+                key: screenshotKey,
+                paDataDir,
+                ingestOutboundImage: deps.ingestOutboundImage,
+            });
+            if (att)
+                attachments = [att];
+        }
+        try {
+            await deps.messageHub.sendToPlatform(parsed.platform, parsed.channelId, text, undefined, attachments);
+            return { ok: true };
+        }
+        catch (err) {
+            const reason = err instanceof MessageDeliveryError
+                ? err.message
+                : err instanceof Error
+                    ? err.message
+                    : String(err);
+            logger.warn({ ref, reason }, "B-4 system DM dispatch failed");
+            return { ok: false, reason };
+        }
+    }
+    return {
+        async deliverPurchaseRequest(capability, input) {
+            assertCapability(capability);
+            const headerLine = `🔐 ${PURCHASE_CONFIRMATION_HEADER}`;
+            const lines = [
+                headerLine,
+                `Site: ${input.siteKey}`,
+                `Total: ${formatAmount(input.displayedTotalMinor, input.currency)}`,
+                input.notesForUser
+                    ? `Agent's rationale: ${input.notesForUser}`
+                    : null,
+                `Expires in ${formatExpiry(input.expiresAt, now())} — reply with the exact token below to confirm.`,
+                ``,
+                input.token,
+                ``,
+                `[purchase-verify: !verify ${input.token.slice(2)}] · [cancel: !cancel-purchase] · jti=${input.jti}`,
+            ]
+                .filter((s) => s !== null)
+                .join("\n");
+            const screenshotKey = input.preScreenshotPath || undefined;
+            const delivered = [];
+            const failed = [];
+            for (const ref of input.channels) {
+                const result = await dispatch(ref, lines, screenshotKey);
+                if (result.ok)
+                    delivered.push(ref);
+                else
+                    failed.push(ref);
+            }
+            logger.info({
+                jti: input.jti,
+                siteKey: input.siteKey,
+                tokenRedacted: redactToken(input.token),
+                deliveredCount: delivered.length,
+                failedCount: failed.length,
+            }, "B-4 purchase request DM dispatched");
+            return { delivered, failed };
+        },
+        async deliverPostConsumeFollowup(capability, input) {
+            assertCapability(capability);
+            const consumedMsg = `✅ Confirmed. Aitne is finalising the purchase now. jti=${input.jti}`;
+            const otherMsg = (consumedOn) => `✅ Approved on ${consumedOn} at ${new Date(now()).toISOString()}. No action needed here. jti=${input.jti}`;
+            for (const ref of input.deliveredChannels) {
+                const text = ref === input.consumedChannel
+                    ? consumedMsg
+                    : otherMsg(input.consumedChannel);
+                const result = await dispatch(ref, text);
+                if (!result.ok) {
+                    logger.warn({ jti: input.jti, ref, reason: result.reason }, "post-consume follow-up dispatch failed (continuing)");
+                }
+            }
+        },
+        async deliverCancellationFollowup(capability, input) {
+            assertCapability(capability);
+            const text = `⚠️ Purchase request cancelled (${input.reason}). No charge made. jti=${input.jti}`;
+            for (const ref of input.deliveredChannels) {
+                const result = await dispatch(ref, text);
+                if (!result.ok) {
+                    logger.warn({ jti: input.jti, ref, reason: result.reason }, "cancellation follow-up dispatch failed (continuing)");
+                }
+            }
+        },
+        async deliverVerifyReply(capability, input) {
+            assertCapability(capability);
+            const marker = input.ok ? "✅" : "⚠️";
+            const text = `${marker} ${input.detail}`;
+            const result = await dispatch(input.channel, text);
+            if (!result.ok) {
+                logger.warn({ jti: input.jti, channel: input.channel, reason: result.reason }, "verify reply dispatch failed");
+            }
+        },
+    };
+}
+/**
+ * Convenience helper for the cancellation follow-up's audit message —
+ * exported so other daemon-internal cancel paths (the supervisor's
+ * orphan sweep, the dashboard's "cancel pending" action) format the
+ * cancel reason identically. Pure — no I/O.
+ */
+export function describeCancelReason(reason) {
+    switch (reason) {
+        case "user_reply":
+            return "user replied with non-token content";
+        case "wrong_token":
+            return "user replied with a different token";
+        case "wrong_channel":
+            return "token typed on a non-delivered channel";
+        case "timeout":
+            return "5-minute confirmation window elapsed";
+        case "explicit":
+            return "user issued !cancel-purchase";
+        case "amount_mismatch":
+            return "cart total changed under the confirmation pause";
+        case "amount_exceeds_token":
+            return "displayed total exceeded the confirmed amount";
+        case "page_changed":
+            return "cart page mutated during the pause";
+        case "playwright_error":
+            return "browser-automation error before confirm";
+        case "daily_cap_exceeded":
+            return "per-day spend cap reached at resume";
+        case "b4_disabled":
+            return "B-4 master toggle was turned off";
+        case "site_not_enabled":
+            return "site B-4 was disabled mid-flight";
+        case "supervisor_orphan_sweep":
+            return "daemon restart cleaned up an in-flight token";
+        case "dashboard_cancel":
+            return "user clicked Cancel in the dashboard";
+    }
+}

package/dist/messaging/setup-welcome-dm.d.ts

@@ -27,4 +27,3 @@ export declare function sendSetupWelcomeDm(params: {
     db: Database.Database;
     messageHub: MessageHub;
 }): Promise<MessageDelivery[] | null>;
-//# sourceMappingURL=setup-welcome-dm.d.ts.map

package/dist/messaging/setup-welcome-dm.js

@@ -83,4 +83,3 @@ export async function sendSetupWelcomeDm(params) {
     logger.info({ platforms: deliveries.map((d) => d.platform) }, "Welcome DM sent");
     return deliveries;
 }
-//# sourceMappingURL=setup-welcome-dm.js.map

package/dist/messaging/url-extract.d.ts

@@ -5,4 +5,3 @@ export interface UrlExtractResult {
     urls: string[];
 }
 export declare function extractHttpUrls(input: string, limit?: number): UrlExtractResult;
-//# sourceMappingURL=url-extract.d.ts.map

package/dist/messaging/url-extract.js

@@ -21,9 +21,14 @@ export function extractHttpUrls(input, limit = 10) {
         catch {
             continue;
         }
+        // Defensive: the candidate regex only matches http(s) prefixes and
+        // URL never normalises away from http/https. Preserved in case the
+        // regex is ever widened — kept out of the coverage gate via v8-ignore.
+        /* v8 ignore start */
         if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
             continue;
         }
+        /* v8 ignore stop */
         const normalized = parsed.toString();
         if (seen.has(normalized))
             continue;
@@ -38,4 +43,3 @@ export function extractHttpUrls(input, limit = 10) {
     }
     return { urls };
 }
-//# sourceMappingURL=url-extract.js.map

package/dist/observers/browser-history-poller.d.ts

@@ -0,0 +1,113 @@
+import type Database from "better-sqlite3";
+import type { Observer } from "./manager.js";
+import type { AgentConfig } from "../config.js";
+import type { HostProfile } from "../services/browser-history/types.js";
+import { type OfferRateLimitConfig } from "../services/browser-history/pipeline/offer-rate-limit.js";
+import type { Event } from "@aitne/shared";
+export declare const SHOPPING_COMPARISON_MIN_ASINS = 3;
+export declare const SHOPPING_COMPARISON_WINDOW_MS: number;
+export interface ShoppingVisitPoint {
+    ts: number;
+    asin: string;
+}
+export interface ShoppingWindowSession {
+    asins: string[];
+    firstMs: number;
+    lastMs: number;
+}
+/**
+ * Greedy sliding 90-min window over ASIN visits in time order. Each
+ * emission is the maximal extension that still contains ≥3 distinct
+ * ASINs; advancing past the emitted window prevents overlapping
+ * duplicates while still surfacing distinct morning/evening bursts as
+ * separate sessions. Pure function — caller buckets by day+locale.
+ */
+export declare function detectShoppingSessions(visits: readonly ShoppingVisitPoint[], windowMs?: number, minAsins?: number): ShoppingWindowSession[];
+/**
+ * BrowserHistoryPoller — P2 Layer 1 runner.
+ *
+ * On a fixed cadence the poller:
+ *   1. Re-detects browser capabilities (cheap; just confirms profiles still
+ *      resolve and consent is still granted).
+ *   2. For each ingest-enabled Chromium profile, snapshots the live
+ *      `History` SQLite, reads visits newer than the persisted cursor,
+ *      and runs the deterministic pipeline (redactor → classifier →
+ *      meaningful-filter → amazon-extractor → reload-detector) before
+ *      writing normalized rows into `browser_visits` and aggregating
+ *      reload counts.
+ *   3. Recomputes research clusters from `browser_visits` and upserts
+ *      `browser_research_clusters`.
+ *   4. Materialises shopping sessions (Amazon-only at MVP) for the
+ *      yesterday/today day boundaries that intersect the new visits.
+ *   5. Enforces row + search-query retention.
+ *
+ * There is no LLM in this loop. The poller cooperates with the lifecycle
+ * supervisor: the supervisor keeps the browser running so the History DB
+ * is fresh; the poller reads from it.
+ */
+export interface BrowserHistoryPollerOptions {
+    host?: HostProfile;
+    intervalMinutes?: number;
+    /**
+     * BROWSER_HISTORY_INTEGRATION_PLAN §5.F1 (seventh-pass) — replaces
+     * the previous `notifyOwner` callback. When the per-cluster qualifier
+     * AND the rate-limit gate both say "fire", the poller enqueues a
+     * `routine.research_offer_dm` event onto this EventBus. The
+     * subsequent agent session reads the OfferContext payload from
+     * `event.data`, composes the natural-language two-option DM, and
+     * sends it via the standard notifier path (which records the
+     * outbound into the owner DM conversation_sessions so the DM agent
+     * sees it on the user's reply turn — §10.5 invariant). When absent
+     * (test fixtures, daemon early-boot), the poller still computes
+     * candidates but skips the enqueue without advancing `last_dm_at`,
+     * so the offer is retried the next cycle once the bus is up.
+     */
+    enqueueEvent?: (event: Event) => Promise<void>;
+    /** Optional rate-limit config override for tests. */
+    rateLimitConfig?: OfferRateLimitConfig;
+}
+export declare class BrowserHistoryPoller implements Observer {
+    private readonly db;
+    private readonly config;
+    readonly name = "browser-history-poller";
+    private timer;
+    private host;
+    private readonly intervalMinutes;
+    private readonly enqueueEvent?;
+    private readonly rateLimitConfig;
+    private readonly guard;
+    constructor(db: Database.Database, config: AgentConfig, options?: BrowserHistoryPollerOptions);
+    /**
+     * Build the offer rate-limit config from AgentConfig at construction
+     * time. Quiet-hours + timezone are read from the daemon config; the
+     * cap / interval / decline-backoff / active-conversation values are
+     * the seventh-pass design defaults (2/day, 4h, 30d, 30min). Pulled
+     * into a method so tests can override via `rateLimitConfig` while
+     * production picks up the per-install timezone automatically.
+     */
+    private deriveRateLimitConfig;
+    private boundary;
+    private agentDayKey;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private tick;
+    private runIngestCycle;
+    /**
+     * Walk every active cluster, build its engagement snapshot, evaluate
+     * the offer-trigger ladder, and fire whichever trigger wins. Always
+     * runs AFTER `upsertResearchClusters` so the freshly-upserted row
+     * (with new `last_activity_at`) feeds the budget gate.
+     *
+     * Dispatch order: DM first (via `notifyOwner`), then stamp the row
+     * and write the pending-offer ledger row. If the DM throws, the row
+     * is left untouched so the next cycle retries — at worst a duplicate
+     * DM lands, never a silent suppression. The DM budget gate
+     * (`dmBudgetMs`) keeps duplicates bounded.
+     */
+    private evaluateAndFireOfferTriggers;
+    private fireDecision;
+    private logRateLimitSkip;
+    private profilesForBrowser;
+    private ingestProfile;
+    private refreshShoppingSessions;
+}