@aitne/daemon 0.1.7 → 0.1.9

package/dist/api/routes/backends.js

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
 import { z } from "zod";
-import { ADVISOR_ALLOWED_MODELS, API_KEY_PROVIDERS_BY_BACKEND, CONFIGURABLE_PROCESS_KEYS, WEB_SEARCH_CAPABLE_BACKENDS, backendApiKeyConfigSchema, getBackendIds, getDefaultTierForProcessKey, isAdvisorModel, isBackendId, isConfigurableProcessKey, validateBackendApiKeyConfigFormat, } from "@aitne/shared";
-import { createLogger } from "../../logging.js";
+import { ADVISOR_ALLOWED_MODELS, API_KEY_PROVIDERS_BY_BACKEND, CONFIGURABLE_PROCESS_KEYS, RUNTIME_AVAILABLE_BACKEND_IDS, WEB_SEARCH_CAPABLE_BACKENDS, backendApiKeyConfigSchema, getBackendIds, getDefaultTierForProcessKey, isAdvisorModel, isBackendId, isConfigurableProcessKey, isRuntimeAvailableBackendId, validateBackendApiKeyConfigFormat, } from "@aitne/shared";
+import { createLogger, toSafeErrorMessage } from "../../logging.js";
 import { DEFAULT_CLAUDE_HIGH_MODEL, DEFAULT_CLAUDE_LITE_MODEL, DEFAULT_CLAUDE_MEDIUM_MODEL, getModelsForBackend, } from "../../core/backends/model-registry.js";
 import { setProcessBackendConfig } from "../../core/backends/process-config-cascade.js";
 import { queryChatBinding } from "../chat-binding-query.js";
@@ -17,6 +17,7 @@ import { readIntegrations } from "../../db/integrations-store.js";
 import { writeManagementMd } from "../../core/management-md.js";
 const logger = createLogger("backends-api");
 import { PriceFetcher } from "../../core/backends/price-fetcher.js";
+import { OpencodeCore } from "../../core/backends/opencode-core.js";
 const updateDefaultsSchema = z.object({
     defaultBackend: z.string().refine(isBackendId),
     defaultLiteModel: z.string().min(1),
@@ -56,6 +57,23 @@ export function createBackendRoutes(deps) {
             message: "Multi-backend tables are not available. Run migrations first.",
         };
     }
+    /**
+     * Common error body for destructive write paths that target a backend
+     * registered in `BACKEND_IDS` but whose `IAgentCore` is not yet wired
+     * into the BackendRouter (`docs/design/appendices/opencode-backend.md` Phase 1: opencode
+     * is type-system-registered but its core lands in Phase 2). Returning
+     * this at the API layer prevents a process_backend_config row pointing
+     * at the not-yet-wired backend from being written and then failing later
+     * with `BackendDecisiveFailure(model_unavailable)` at dispatch time.
+     */
+    function backendNotRuntimeSupportedResponse(backendId) {
+        return {
+            error: "backend_not_runtime_supported",
+            message: `Backend "${backendId}" is registered but not yet supported at runtime in this build. Pick one of: ${RUNTIME_AVAILABLE_BACKEND_IDS.join(", ")}.`,
+            backendId,
+            runtimeAvailableBackends: [...RUNTIME_AVAILABLE_BACKEND_IDS],
+        };
+    }
     function readDefaults() {
         const row = db
             .prepare(`SELECT default_backend, default_lite_model, default_medium_model, default_high_model
@@ -79,9 +97,15 @@ export function createBackendRoutes(deps) {
            FROM backends`)
             .all();
         const rowById = new Map(rows.map((row) => [row.id, row]));
+        // For backends that have never been touched, synthesize a ghost row.
+        // `enabled` tracks the configured main backend rather than hard-coding
+        // claude: switching `default_backend` to opencode/codex/gemini must not
+        // leave the operator with a "disabled" row when no real backends row
+        // has been written yet (e.g. fresh install, manual default override).
+        const defaults = readDefaults();
         return getBackendIds().map((backendId) => rowById.get(backendId) ?? {
             id: backendId,
-            enabled: backendId === "claude" ? 1 : 0,
+            enabled: backendId === defaults.default_backend ? 1 : 0,
             auth_method: null,
             auth_status: "unknown",
             auth_checked_at: null,
@@ -133,7 +157,19 @@ export function createBackendRoutes(deps) {
         });
     }
     function ensureModelBelongsToBackend(backendId, modelId) {
-        return getModelsForBackend(backendId).some((model) => model.modelId === modelId);
+        if (getModelsForBackend(backendId).some((model) => model.modelId === modelId)) {
+            return true;
+        }
+        // opencode's effective catalogue is the live `client.config.providers()`
+        // response, which the static registry only seeds the Anthropic preset
+        // for. Accept any `<provider>/<model>` composite here; the runtime
+        // (`OpencodeCore.execute`) surfaces an unambiguous "Model not found"
+        // if the operator typed something the live server can't route to.
+        if (backendId === "opencode") {
+            const slash = modelId.indexOf("/");
+            return slash > 0 && slash < modelId.length - 1;
+        }
+        return false;
     }
     function ensureBackendEnabled(backendId) {
         const row = db
@@ -243,6 +279,34 @@ export function createBackendRoutes(deps) {
         }
         return c.json(serializeBackends());
     });
+    // GET /backends/opencode/live-models — live enumeration over
+    // `client.config.providers()` for the model picker. Returns every
+    // provider configured on the running opencode server with its full
+    // model catalogue + capability + cost metadata, projected and
+    // redacted (no provider API keys leave the daemon). Cached in
+    // `OpencodeCore` for 5 minutes; pass `?refresh=1` to force-refetch
+    // after the operator runs `opencode auth login`.
+    app.get("/backends/opencode/live-models", async (c) => {
+        const opencodeCore = coreById["opencode"];
+        if (!(opencodeCore instanceof OpencodeCore)) {
+            return c.json({
+                error: "opencode_unavailable",
+                message: "OpenCode backend is not wired into this daemon build.",
+            }, 503);
+        }
+        const refresh = c.req.query("refresh") === "1";
+        try {
+            const payload = await opencodeCore.listLiveModels({ forceRefresh: refresh });
+            return c.json(payload);
+        }
+        catch (err) {
+            logger.warn({ err }, "live opencode model enumeration failed");
+            // toSafeErrorMessage runs the SDK error through the secret-redaction
+            // pass so a stray `Bearer …` or provider key in the error string
+            // doesn't reach the dashboard.
+            return c.json({ error: "live_models_failed", message: toSafeErrorMessage(err, "live_models_failed") }, 502);
+        }
+    });
     app.put("/backends/defaults", async (c) => {
         if (!hasMultiBackendTables()) {
             return c.json(backendTablesUnavailableResponse(), 503);
@@ -253,6 +317,9 @@ export function createBackendRoutes(deps) {
             return c.json({ error: "validation_error", details: parsed.error.flatten() }, 400);
         }
         const { defaultBackend, defaultLiteModel, defaultMediumModel, defaultHighModel, } = parsed.data;
+        if (!isRuntimeAvailableBackendId(defaultBackend)) {
+            return c.json(backendNotRuntimeSupportedResponse(defaultBackend), 400);
+        }
         if (!ensureBackendEnabled(defaultBackend)) {
             return c.json({ error: "backend_disabled", message: `Backend "${defaultBackend}" is not enabled.` }, 409);
         }
@@ -374,6 +441,20 @@ export function createBackendRoutes(deps) {
             else if (backendIdRaw === "gemini") {
                 recovery = await deps.authRecovery.initiateGeminiAuth();
             }
+            else if (backendIdRaw === "opencode") {
+                // OpenCode's auth model is per-provider via `opencode auth login`
+                // and is not an OAuth/device-flow the daemon can drive headlessly.
+                // Return 400 with a `message` field so the dashboard's `ApiError`
+                // surface (which reads `body.message ?? body.error`) renders the
+                // manual command in its existing toast pipeline. The structured
+                // `recoveryCommand` field is preserved for programmatic callers.
+                return c.json({
+                    error: "manual_recovery_required",
+                    backendId: backendIdRaw,
+                    recoveryCommand: "opencode auth login",
+                    message: "OpenCode recovery is manual. Run `opencode auth login` in a terminal to add or refresh provider credentials, then re-run the auth probe.",
+                }, 400);
+            }
             else {
                 return c.json({ error: "recovery_not_supported", detail: `Recovery for ${backendIdRaw} is not supported` }, 400);
             }
@@ -702,6 +783,9 @@ export function createBackendRoutes(deps) {
             return c.json({ error: "validation_error", details: parsed.error.flatten() }, 400);
         }
         const { mainBackend, mainModel, fallbackBackend, fallbackModel, maxTurns, maxBudgetUsd, } = parsed.data;
+        if (!isRuntimeAvailableBackendId(mainBackend)) {
+            return c.json(backendNotRuntimeSupportedResponse(mainBackend), 400);
+        }
         if (!ensureBackendEnabled(mainBackend)) {
             return c.json({ error: "main_backend_disabled", message: `Backend "${mainBackend}" is not enabled.` }, 409);
         }
@@ -722,6 +806,10 @@ export function createBackendRoutes(deps) {
                 message: "Fallback backend must differ from the main backend.",
             }, 400);
         }
+        if (normalizedFallbackBackend
+            && !isRuntimeAvailableBackendId(normalizedFallbackBackend)) {
+            return c.json(backendNotRuntimeSupportedResponse(normalizedFallbackBackend), 400);
+        }
         if (normalizedFallbackBackend && !ensureBackendEnabled(normalizedFallbackBackend)) {
             return c.json({
                 error: "fallback_backend_disabled",
@@ -793,12 +881,54 @@ export function createBackendRoutes(deps) {
             return c.json({ error: "validation_error", details: parsed.error.flatten() }, 400);
         }
         const { backendId, force } = parsed.data;
+        if (!isRuntimeAvailableBackendId(backendId)) {
+            return c.json(backendNotRuntimeSupportedResponse(backendId), 400);
+        }
         const previousMain = readDefaults().default_backend;
-        setMainBackend(db, backendId);
-        const result = applyDefaultPresets(db, {
-            defaultBackend: backendId,
-            force: force ?? false,
-        });
+        // All persistent DB mutations for a main-backend switch must succeed
+        // atomically — `default_backend`, the `process_backend_config` re-seed,
+        // the native cascade, and the native_unbound audit rows are mutually
+        // load-bearing. Better-sqlite3 turns nested `db.transaction()` calls
+        // into SAVEPOINTs, so wrapping these composes safely with the inner
+        // transactions inside setMainBackend / applyDefaultPresets. The fs
+        // (`writeManagementMd`) and notification side-effects intentionally
+        // stay outside this tx — they cannot be rolled back.
+        const txOutcome = db.transaction(() => {
+            setMainBackend(db, backendId);
+            const presetResult = applyDefaultPresets(db, {
+                defaultBackend: backendId,
+                force: force ?? false,
+            });
+            let cascade = [];
+            if (backendId !== previousMain) {
+                const integrationsBefore = readIntegrations(db);
+                cascade = cascadeNativeBindingsOnMainSwitch(db, backendId);
+                for (const entry of cascade) {
+                    try {
+                        db.prepare(`INSERT INTO agent_actions
+                 (event_id, action_type, trigger, result, detail, started_at, completed_at)
+               VALUES (?, 'integration.native_unbound', 'reactive', 'success', ?, datetime('now'), datetime('now'))`).run(`integration:${entry.key}:native_unbound:${Date.now()}`, JSON.stringify({
+                            key: entry.key,
+                            priorMode: "native",
+                            priorNativeBackend: entry.priorNativeBackend,
+                            newMainBackend: entry.newMainBackend,
+                            // Carry the deniedTools snapshot so a future re-flip-to-
+                            // native restore can be reconstructed without re-querying
+                            // the now-cleared row.
+                            priorDeniedTools: integrationsBefore[entry.key].deniedTools ?? [],
+                        }));
+                        /* c8 ignore start -- in-memory DB always succeeds; catch is defensive */
+                    }
+                    catch (err) {
+                        logger.warn({ err, key: entry.key }, "failed to write integration.native_unbound audit row");
+                    }
+                    /* c8 ignore stop */
+                }
+            }
+            return { presetResult, cascade };
+        })();
+        const result = txOutcome.presetResult;
+        const nativeCascade = txOutcome.cascade;
         const warnings = getAuthWarnings(backendId);
         logger.info({
             backendId,
@@ -806,37 +936,7 @@ export function createBackendRoutes(deps) {
             processRowsUpdated: result.processRowsUpdated,
             processRowsSkipped: result.processRowsSkipped,
         }, "Main backend switched");
-        // INTEGRATION_NATIVE_MODE_DESIGN.md §11.4 — main-backend change
-        // cascade. Capture the pre-cascade snapshot of each native row so we
-        // can write `integration.native_unbound` audit rows for any row that
-        // gets flipped to `disabled`. Runs BEFORE the `onMainBackendChange`
-        // notification so the workdir re-materialise step sees the post-
-        // cascade state and the skill bundle reflects the new mode.
-        let nativeCascade = [];
         if (backendId !== previousMain) {
-            const integrationsBefore = readIntegrations(db);
-            nativeCascade = cascadeNativeBindingsOnMainSwitch(db, backendId);
-            for (const entry of nativeCascade) {
-                try {
-                    db.prepare(`INSERT INTO agent_actions
-               (event_id, action_type, trigger, result, detail, started_at, completed_at)
-             VALUES (?, 'integration.native_unbound', 'reactive', 'success', ?, datetime('now'), datetime('now'))`).run(`integration:${entry.key}:native_unbound:${Date.now()}`, JSON.stringify({
-                        key: entry.key,
-                        priorMode: "native",
-                        priorNativeBackend: entry.priorNativeBackend,
-                        newMainBackend: entry.newMainBackend,
-                        // Carry the deniedTools snapshot so a future re-flip-to-
-                        // native restore can be reconstructed without re-querying
-                        // the now-cleared row.
-                        priorDeniedTools: integrationsBefore[entry.key].deniedTools ?? [],
-                    }));
-                    /* c8 ignore start -- in-memory DB always succeeds; catch is defensive */
-                }
-                catch (err) {
-                    logger.warn({ err, key: entry.key }, "failed to write integration.native_unbound audit row");
-                }
-                /* c8 ignore stop */
-            }
             // INTEGRATION_NATIVE_MODE_DESIGN.md §11.4 — cascade flipped native
             // rows to `disabled` directly in the DB. Mirror that into the
             // on-disk `integrations.md` so the human-readable file does not
@@ -1140,6 +1240,11 @@ export function createBackendRoutes(deps) {
                 case "gemini":
                     apiKeyConfig = { provider: "google", apiKey };
                     break;
+                case "opencode":
+                    return c.json({
+                        error: "structured_config_required",
+                        message: "OpenCode requires a structured server configuration.",
+                    }, 400);
             }
         }
         const formatHint = validateBackendApiKeyConfigFormat(backendIdRaw, apiKeyConfig);
@@ -1224,4 +1329,3 @@ export function createBackendRoutes(deps) {
     });
     return app;
 }
-//# sourceMappingURL=backends.js.map

package/dist/api/routes/books.d.ts

@@ -60,4 +60,3 @@ export interface ImportNotebookResult {
 }
 export declare function importKindleNotebook(db: ApiDependencies["db"], parsed: KindleNotebookExport): ImportNotebookResult;
 export declare function createBookRoutes(deps: ApiDependencies): Hono;
-//# sourceMappingURL=books.d.ts.map

package/dist/api/routes/books.js

@@ -1,4 +1,5 @@
 import { Hono } from "hono";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 /**
  * Parse Kindle "My Clippings.txt" format.
  *
@@ -44,11 +45,11 @@ export function parseKindleClippings(text) {
                 highlightedAt = null;
             }
         }
-        // Line 2 is blank, content starts at line 3
         const content = lines.slice(3).join("\n").trim();
         if (!content)
             continue;
-        // Skip bookmarks (they have no content or are just location markers)
+        // Skip bookmarks — Kindle exports them as entries with the same shape
+        // as highlights but no body, only a location marker.
         if (metaLine.includes("Bookmark"))
             continue;
         highlights.push({ bookKey, content, location, highlightedAt });
@@ -231,7 +232,6 @@ export function createBookRoutes(deps) {
        FROM books ${where}
        ORDER BY COALESCE(completed_at, started_at, created_at) DESC
        LIMIT ? OFFSET ?`).all(...params, limit, offset);
-        // Attach highlight count per book
         const bookIds = rows.map((r) => r.id);
         const highlightCounts = new Map();
         if (bookIds.length > 0) {
@@ -269,9 +269,13 @@ export function createBookRoutes(deps) {
      * GET /books/:id/highlights — get highlights for a book.
      */
     app.get("/books/:id/highlights", (c) => {
-        const bookId = parseInt(c.req.param("id"), 10);
-        if (isNaN(bookId))
-            return c.json({ error: "invalid_id" }, 400);
+        const rawId = c.req.param("id");
+        const bookId = parseInt(rawId, 10);
+        if (isNaN(bookId) || bookId <= 0) {
+            return respondWithAgentError(c, 400, [
+                composeIssue("books.invalid_id", { field: "id", received: rawId }),
+            ]);
+        }
         const limit = Math.min(Math.max(parseInt(c.req.query("limit") ?? "100", 10), 1), 500);
         const rows = db.prepare(`SELECT id, book_id, content, location, note, highlighted_at, created_at
        FROM reading_highlights
@@ -312,22 +316,30 @@ export function createBookRoutes(deps) {
      * PATCH /books/:id — update book status, rating, or notes.
      */
     app.patch("/books/:id", async (c) => {
-        const id = parseInt(c.req.param("id"), 10);
-        if (isNaN(id))
-            return c.json({ error: "invalid_id" }, 400);
+        const rawId = c.req.param("id");
+        const id = parseInt(rawId, 10);
+        if (isNaN(id) || id <= 0) {
+            return respondWithAgentError(c, 400, [
+                composeIssue("books.invalid_id", { field: "id", received: rawId }),
+            ]);
+        }
         let body;
         try {
             body = await c.req.json();
         }
         catch {
-            return c.json({ error: "invalid_json" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("books.invalid_json", { field: "body", received: "<unparseable>" }),
+            ]);
         }
         const validStatuses = ["reading", "completed", "abandoned"];
         if (body.status && !validStatuses.includes(body.status)) {
-            return c.json({ error: "invalid_status", valid: validStatuses }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("books.invalid_status", { field: "status", received: body.status })], { legacyFields: { valid: validStatuses } });
         }
         if (body.rating !== undefined && (body.rating < 1 || body.rating > 5)) {
-            return c.json({ error: "rating_must_be_1_to_5" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("books.rating_must_be_1_to_5", { field: "rating", received: body.rating }),
+            ]);
         }
         const updates = [];
         const params = [];
@@ -337,6 +349,9 @@ export function createBookRoutes(deps) {
             if (body.status === "completed") {
                 updates.push("completed_at = datetime('now')");
             }
+            else {
+                updates.push("completed_at = NULL");
+            }
         }
         if (body.rating !== undefined) {
             updates.push("rating = ?");
@@ -347,12 +362,16 @@ export function createBookRoutes(deps) {
             params.push(body.notes);
         }
         if (updates.length === 0) {
-            return c.json({ error: "no_updates" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("books.no_updates", { field: "body", received: body }),
+            ]);
         }
         params.push(id);
         const result = db.prepare(`UPDATE books SET ${updates.join(", ")} WHERE id = ?`).run(...params);
         if (result.changes === 0) {
-            return c.json({ error: "not_found" }, 404);
+            return respondWithAgentError(c, 404, [
+                composeIssue("books.not_found", { field: "id", received: id }),
+            ]);
         }
         return c.json({ ok: true, id });
     });
@@ -366,26 +385,33 @@ export function createBookRoutes(deps) {
         const MAX_BODY_BYTES = 10 * 1024 * 1024;
         const contentLength = parseInt(c.req.header("content-length") ?? "0", 10);
         if (contentLength > MAX_BODY_BYTES) {
-            return c.json({ error: "payload_too_large", maxBytes: MAX_BODY_BYTES }, 413);
+            return respondWithAgentError(c, 413, [
+                composeIssue("books.payload_too_large", {
+                    field: "content-length",
+                    received: contentLength,
+                }),
+            ], { legacyFields: { maxBytes: MAX_BODY_BYTES } });
         }
         let body;
         try {
             body = await c.req.json();
         }
         catch {
-            return c.json({ error: "invalid_json" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("books.invalid_json", { field: "body", received: "<unparseable>" }),
+            ]);
         }
         if (!body.data) {
-            return c.json({ error: "data_required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("books.data_required", { field: "data", received: "<missing>" }),
+            ]);
         }
         const { books: bookMap, highlights } = parseKindleClippings(body.data);
-        // Upsert books
         const insertHighlight = db.prepare(`INSERT INTO reading_highlights (book_id, content, location, highlighted_at)
        VALUES (?, ?, ?, ?)`);
         let booksCreated = 0;
         let highlightsInserted = 0;
         const importAll = db.transaction(() => {
-            // Map bookKey → book id
             const bookIdMap = new Map();
             for (const [key, { title, author }] of bookMap) {
                 // Use COALESCE to match the UNIQUE index on (title, COALESCE(author, ''))
@@ -401,12 +427,12 @@ export function createBookRoutes(deps) {
                     booksCreated++;
                 }
             }
-            // Insert highlights (check for duplicates by content + book_id)
             for (const h of highlights) {
                 const bookId = bookIdMap.get(h.bookKey);
                 if (!bookId)
                     continue;
-                // Simple dedup: check if identical content exists for this book
+                // Dedup by exact content match within the same book — Kindle
+                // exports duplicate every highlight on each re-export.
                 const exists = db.prepare(`SELECT 1 FROM reading_highlights WHERE book_id = ? AND content = ?`).get(bookId, h.content);
                 if (exists)
                     continue;
@@ -433,24 +459,38 @@ export function createBookRoutes(deps) {
         const MAX_BODY_BYTES = 10 * 1024 * 1024;
         const contentLength = parseInt(c.req.header("content-length") ?? "0", 10);
         if (contentLength > MAX_BODY_BYTES) {
-            return c.json({ error: "payload_too_large", maxBytes: MAX_BODY_BYTES }, 413);
+            return respondWithAgentError(c, 413, [
+                composeIssue("books.payload_too_large", {
+                    field: "content-length",
+                    received: contentLength,
+                }),
+            ], { legacyFields: { maxBytes: MAX_BODY_BYTES } });
         }
         let body;
         try {
             body = await c.req.json();
         }
         catch {
-            return c.json({ error: "invalid_json" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("books.invalid_json", { field: "body", received: "<unparseable>" }),
+            ]);
         }
         if (!body.html) {
-            return c.json({ error: "html_required" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("books.html_required", { field: "html", received: "<missing>" }),
+            ]);
         }
         const parsed = parseKindleNotebookHtml(body.html, {
             subject: body.subject ?? null,
             date: body.date ?? null,
         });
         if (!parsed) {
-            return c.json({ error: "unrecognized_format" }, 422);
+            return respondWithAgentError(c, 422, [
+                composeIssue("books.unrecognized_format", {
+                    field: "html",
+                    received: "<unrecognized Kindle notebook shape>",
+                }),
+            ]);
         }
         const result = importKindleNotebook(db, parsed);
         return c.json({
@@ -464,4 +504,3 @@ export function createBookRoutes(deps) {
     });
     return app;
 }
-//# sourceMappingURL=books.js.map

package/dist/api/routes/browser-automation-purchase.d.ts

@@ -0,0 +1,31 @@
+/**
+ * /api/browser-automation/purchase-tokens/* + /api/browser-automation/b4/*
+ * — Phase B-4 experimental purchase surface.
+ *
+ * MANAGED_CHROMIUM_IMPLEMENTATION_PLAN.md §17.8 / §17.10 / §13 step 55.
+ *
+ * Routes:
+ *   GET    /purchase-tokens                       — list pending + recent (Approve)
+ *   DELETE /purchase-tokens/:jti                  — cancel a pending token (Approve)
+ *   GET    /b4/enabled                            — global master toggle status (Autonomous)
+ *   POST   /b4/enabled                            — flip the master toggle (Approve, with body { enabled: bool, acknowledge: true })
+ *   GET    /b4/site-configs                       — per-site B-4 config rows (Autonomous)
+ *   PATCH  /sites/:siteKey/b4-config              — update per-site config (Approve)
+ *   GET    /b4/primary-channels                   — list primary channels (Autonomous)
+ *   PATCH  /channels/:platform/:channelId/primary — set/unset (Approve)
+ *
+ * The dashboard does NOT have an issuance form — tokens are issued by
+ * the daemon when a B-4 workflow is invoked, and delivered to DM
+ * channels, not the dashboard. The dashboard role is configuration +
+ * audit (§17.8). The raw `!~xxxxxxxx` token NEVER leaves the
+ * `purchase_tokens` table; the wire shapes carry only the server-side
+ * `jti` + the delivery state, so even an attacker who briefly
+ * compromises dashboard credentials cannot extract live tokens.
+ *
+ * Excluded from the 100% coverage gate — the file is route glue; the
+ * pure decision logic lives in `purchase-tokens.ts` and the DB CAS
+ * predicates in the stores.
+ */
+import { Hono } from "hono";
+import type { ApiDependencies } from "../server.js";
+export declare function createBrowserAutomationPurchaseRoutes(deps: ApiDependencies): Hono;