@aitne/daemon 0.1.7 → 0.1.9

package/dist/api/routes/mail/validators.js

@@ -0,0 +1,130 @@
+export function parseIntParam(raw, fallback, bounds) {
+    if (!raw)
+        return fallback;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n))
+        return fallback;
+    return Math.max(bounds.min, Math.min(bounds.max, n));
+}
+export function toStringArray(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        return null;
+    if (value.every((v) => typeof v === "string"))
+        return value;
+    return null;
+}
+export function validateSendInput(body) {
+    const raw = body;
+    const to = toStringArray(raw?.to);
+    if (!to || to.length === 0) {
+        return {
+            ok: false,
+            code: "invalid_body",
+            message: "to: non-empty string[] required",
+        };
+    }
+    if (typeof raw.subject !== "string") {
+        return {
+            ok: false,
+            code: "invalid_body",
+            message: "subject: string required",
+        };
+    }
+    const cc = raw.cc === undefined ? undefined : toStringArray(raw.cc);
+    const bcc = raw.bcc === undefined ? undefined : toStringArray(raw.bcc);
+    if (cc === null || bcc === null) {
+        return {
+            ok: false,
+            code: "invalid_body",
+            message: "cc/bcc must be string[] when present",
+        };
+    }
+    const reply = parseReplyContext(raw.reply);
+    if (reply === "invalid") {
+        return {
+            ok: false,
+            code: "invalid_body",
+            message: "reply requires inReplyToRfc822Id (string) and references (string[])",
+        };
+    }
+    return {
+        ok: true,
+        value: {
+            to,
+            cc,
+            bcc,
+            subject: raw.subject,
+            textBody: typeof raw.textBody === "string" ? raw.textBody : undefined,
+            htmlBody: typeof raw.htmlBody === "string" ? raw.htmlBody : undefined,
+            reply,
+            // `draftOnly` is intentionally NOT surfaced at the route boundary.
+            // Drafts go through POST /mail/:id/drafts (Autonomous tier); sends
+            // go through POST /mail/:id/messages/send (Notify tier). Body flags
+            // cannot be classified by the path-prefix risk classifier.
+        },
+    };
+}
+function parseReplyContext(raw) {
+    if (raw === undefined || raw === null)
+        return undefined;
+    if (typeof raw !== "object")
+        return "invalid";
+    const r = raw;
+    if (typeof r.inReplyToRfc822Id !== "string")
+        return "invalid";
+    const refs = toStringArray(r.references);
+    if (!refs)
+        return "invalid";
+    return {
+        inReplyToRfc822Id: r.inReplyToRfc822Id,
+        references: refs,
+        providerThreadId: typeof r.providerThreadId === "string" ? r.providerThreadId : undefined,
+        parentProviderMsgId: typeof r.parentProviderMsgId === "string"
+            ? r.parentProviderMsgId
+            : undefined,
+    };
+}
+export function validateUpdateDraftInput(body) {
+    const raw = body;
+    const to = raw.to === undefined ? undefined : toStringArray(raw.to);
+    const cc = raw.cc === undefined ? undefined : toStringArray(raw.cc);
+    const bcc = raw.bcc === undefined ? undefined : toStringArray(raw.bcc);
+    if (to === null || cc === null || bcc === null) {
+        return {
+            ok: false,
+            code: "invalid_body",
+            message: "to/cc/bcc must be string[] when present",
+        };
+    }
+    // `reply` tri-state: undefined = leave existing threading; null = clear;
+    // object = reshape (must include inReplyToRfc822Id + references).
+    let reply;
+    if (raw.reply === null) {
+        reply = null;
+    }
+    else if (raw.reply !== undefined) {
+        const parsed = parseReplyContext(raw.reply);
+        if (parsed === "invalid") {
+            return {
+                ok: false,
+                code: "invalid_body",
+                message: "reply requires inReplyToRfc822Id (string) and references (string[]); pass null to clear",
+            };
+        }
+        reply = parsed;
+    }
+    return {
+        ok: true,
+        value: {
+            to,
+            cc,
+            bcc,
+            subject: typeof raw.subject === "string" ? raw.subject : undefined,
+            textBody: typeof raw.textBody === "string" ? raw.textBody : undefined,
+            htmlBody: typeof raw.htmlBody === "string" ? raw.htmlBody : undefined,
+            reply,
+        },
+    };
+}

package/dist/api/routes/managed-tasks.d.ts

@@ -45,4 +45,3 @@ export declare function buildManagedTasksRoutesDepsFromApi(deps: ApiDependencies
  * mounted, so the file converges to the fresh DB state on first run.
  */
 export { bootstrapManagementRegistry };
-//# sourceMappingURL=managed-tasks.d.ts.map

package/dist/api/routes/managed-tasks.js

@@ -5,6 +5,7 @@ import { createRecurringSchedule, deleteRecurringSchedule, getRecurringSchedule,
 import { readJsonBody } from "../json-body.js";
 import { getContextDir } from "../../config.js";
 import { createLogger } from "../../logging.js";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 import { bootstrapManagementRegistry, readAndParseManagementMd, renderAndWriteManagementMd, } from "../../core/management-registry.js";
 import { InMemoryManagementMdWriteLockManager, withManagementMdWriteLock, } from "../../core/management-md-write-lock.js";
 import { rewriteEntityFilesForSourceRename } from "../../core/context/entity-source-rename.js";
@@ -72,7 +73,7 @@ async function loadPreservedRenderOptions(contextDir) {
     /* c8 ignore stop */
 }
 /**
- * Re-render `rules/management.md` from the current DB state, holding
+ * Re-render `policies/management.md` from the current DB state, holding
  * the management-md write lock for the render → atomic write →
  * snapshot trio (§11.1, §11.3). Returns:
  *   - `{ ok: true }` on success
@@ -130,11 +131,16 @@ export function createManagedTasksRoutes(deps) {
     app.get("/managed-tasks/:id", (c) => {
         const id = c.req.param("id");
         if (!isValidManagedTaskId(id)) {
-            return c.json({ error: "invalid_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("managed_tasks.invalid_id", { field: "id", received: id }),
+            ]);
         }
         const item = getManagedTask(db, id);
-        if (!item)
-            return c.json({ error: "not_found" }, 404);
+        if (!item) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("managed_tasks.not_found", { field: "id", received: id }),
+            ]);
+        }
         const schedule = getRecurringSchedule(db, item.schedule_id);
         return c.json({
             item,
@@ -146,14 +152,19 @@ export function createManagedTasksRoutes(deps) {
     app.get("/managed-tasks/:id/runs", (c) => {
         const id = c.req.param("id");
         if (!isValidManagedTaskId(id)) {
-            return c.json({ error: "invalid_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("managed_tasks.invalid_id", { field: "id", received: id }),
+            ]);
         }
         const item = getManagedTask(db, id);
-        if (!item)
-            return c.json({ error: "not_found" }, 404);
+        if (!item) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("managed_tasks.not_found", { field: "id", received: id }),
+            ]);
+        }
         const limit = clampQueryLimit(c.req.query("limit"), 50, 200);
         if (limit === null) {
-            return c.json({ error: "invalid_limit", message: "limit must be a positive integer ≤ 200" }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("managed_tasks.invalid_limit", { field: "limit", received: c.req.query("limit") ?? "<missing>" })], { legacyFields: { message: "limit must be a positive integer ≤ 200" } });
         }
         const rows = db
             .prepare(`SELECT id, action_type, result, detail, started_at, completed_at
@@ -191,11 +202,11 @@ export function createManagedTasksRoutes(deps) {
     app.get("/management-history", (c) => {
         const limit = clampQueryLimit(c.req.query("limit"), 50, 200);
         if (limit === null) {
-            return c.json({ error: "invalid_limit", message: "limit must be a positive integer ≤ 200" }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("managed_tasks.invalid_limit", { field: "limit", received: c.req.query("limit") ?? "<missing>" })], { legacyFields: { message: "limit must be a positive integer ≤ 200" } });
         }
         const cursor = parseBeforeIdCursor(c.req.query("before_id"));
         if (cursor === "invalid") {
-            return c.json({ error: "invalid_cursor", message: "before_id must be a positive integer" }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("managed_tasks.invalid_cursor", { field: "before_id", received: c.req.query("before_id") ?? "<missing>" })], { legacyFields: { message: "before_id must be a positive integer" } });
         }
         const probeLimit = limit + 1;
         const probed = (cursor === null
@@ -238,7 +249,7 @@ export function createManagedTasksRoutes(deps) {
             return parsedBody.response;
         const parsed = managedTaskCreateSchema.safeParse(parsedBody.body);
         if (!parsed.success) {
-            return c.json({ error: "validation_error", details: parsed.error }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("managed_tasks.validation_error", { field: "body", received: parsedBody.body })], { legacyFields: { details: parsed.error } });
         }
         const idempotencyKey = c.req.header("idempotency-key");
         // §11.4 idempotency: an unexpired record short-circuits to the
@@ -265,10 +276,16 @@ export function createManagedTasksRoutes(deps) {
         // and the count race is acceptable: a competing POST that lands at
         // exactly `cap` will fail on the UNIQUE / cap recheck inside the tx.
         if (countManagedTasks(db) >= configuredMaxActiveTasks(config)) {
-            return c.json({
-                error: "cap_reached",
-                message: `Active managed-tasks cap (${configuredMaxActiveTasks(config)}) reached. Stop one before registering another.`,
-            }, 409);
+            return respondWithAgentError(c, 409, [
+                composeIssue("managed_tasks.cap_reached", {
+                    field: "count",
+                    received: countManagedTasks(db),
+                }),
+            ], {
+                legacyFields: {
+                    message: `Active managed-tasks cap (${configuredMaxActiveTasks(config)}) reached. Stop one before registering another.`,
+                },
+            });
         }
         const { intent, app: appLabel, cadence, recurrenceRule, output_path } = parsed.data;
         // §10.1 step 5b duplicate check — the (app_normalized, cadence)
@@ -277,11 +294,17 @@ export function createManagedTasksRoutes(deps) {
         // ("Already managed as mt_xx") instead of relying on the DB error.
         const dup = findManagedTaskByAppCadence(db, appLabel, cadence);
         if (dup) {
-            return c.json({
-                error: "duplicate",
-                message: `A managed task already covers (${dup.app}, ${dup.cadence})`,
-                item: dup,
-            }, 409);
+            return respondWithAgentError(c, 409, [
+                composeIssue("managed_tasks.duplicate", {
+                    field: "(app, cadence)",
+                    received: { app: dup.app, cadence: dup.cadence },
+                }),
+            ], {
+                legacyFields: {
+                    message: `A managed task already covers (${dup.app}, ${dup.cadence})`,
+                    item: dup,
+                },
+            });
         }
         // Resolve timezone from daemon config when omitted, mirroring
         // recurring-schedules.ts's resolveTimezone.
@@ -336,16 +359,27 @@ export function createManagedTasksRoutes(deps) {
                 message.includes("SQLITE_CONSTRAINT_UNIQUE")) {
                 const existing = findManagedTaskByAppCadence(db, appLabel, cadence);
                 if (existing) {
-                    return c.json({
-                        error: "duplicate",
-                        message: "concurrent registration: row already exists",
-                        item: existing,
-                    }, 409);
+                    return respondWithAgentError(c, 409, [
+                        composeIssue("managed_tasks.duplicate", {
+                            field: "(app, cadence)",
+                            received: { app: existing.app, cadence: existing.cadence },
+                        }),
+                    ], {
+                        legacyFields: {
+                            message: "concurrent registration: row already exists",
+                            item: existing,
+                        },
+                    });
                 }
             }
             /* c8 ignore stop */
             logger.error({ err, app: appLabel }, "managed-task POST tx failed");
-            return c.json({ error: "internal_error" }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("managed_tasks.internal_error", {
+                    field: "tx",
+                    received: err instanceof Error ? err.message : String(err),
+                }),
+            ]);
         }
         recordAuditAction(db, "management_task.created", {
             mt_id: inserted.id,
@@ -387,18 +421,23 @@ export function createManagedTasksRoutes(deps) {
     app.patch("/managed-tasks/:id", async (c) => {
         const id = c.req.param("id");
         if (!isValidManagedTaskId(id)) {
-            return c.json({ error: "invalid_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("managed_tasks.invalid_id", { field: "id", received: id }),
+            ]);
         }
         const parsedBody = await readJsonBody(c, { maxBytes: 32 * 1024 });
         if (!parsedBody.ok)
             return parsedBody.response;
         const parsed = managedTaskPatchSchema.safeParse(parsedBody.body);
         if (!parsed.success) {
-            return c.json({ error: "validation_error", details: parsed.error }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("managed_tasks.validation_error", { field: "body", received: parsedBody.body })], { legacyFields: { details: parsed.error } });
         }
         const existing = getManagedTask(db, id);
-        if (!existing)
-            return c.json({ error: "not_found" }, 404);
+        if (!existing) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("managed_tasks.not_found", { field: "id", received: id }),
+            ]);
+        }
         const data = parsed.data;
         let updated = null;
         try {
@@ -421,11 +460,19 @@ export function createManagedTasksRoutes(deps) {
         }
         catch (err) {
             logger.error({ err, id }, "managed-task PATCH tx failed");
-            return c.json({ error: "internal_error" }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("managed_tasks.internal_error", {
+                    field: "tx",
+                    received: err instanceof Error ? err.message : String(err),
+                }),
+            ]);
         }
         /* c8 ignore next 1 — updateManagedTask is non-null when the row existed above */
-        if (!updated)
-            return c.json({ error: "not_found" }, 404);
+        if (!updated) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("managed_tasks.not_found", { field: "id", received: id }),
+            ]);
+        }
         recordAuditAction(db, "management_task.modified", {
             mt_id: id,
             // Top-level `app` / `app_normalized` are required by the activity-
@@ -433,7 +480,7 @@ export function createManagedTasksRoutes(deps) {
             // `$.app_normalized`, and `buildActivitySnapshot`'s "Recently
             // changed" query selects per-source via the same path. Without
             // them every lifecycle event but `created` is silently dropped
-            // from `_activity/<source>.md`.
+            // from `state/activity/<source>.md`.
             app: existing.app,
             app_normalized: normalizeAppLabel(existing.app),
             changed: Object.keys(data),
@@ -474,22 +521,27 @@ export function createManagedTasksRoutes(deps) {
     app.patch("/managed-tasks/:id/run-result", async (c) => {
         const id = c.req.param("id");
         if (!isValidManagedTaskId(id)) {
-            return c.json({ error: "invalid_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("managed_tasks.invalid_id", { field: "id", received: id }),
+            ]);
         }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
             return parsedBody.response;
         const parsed = managedTaskRunResultSchema.safeParse(parsedBody.body);
         if (!parsed.success) {
-            return c.json({ error: "validation_error", details: parsed.error }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("managed_tasks.validation_error", { field: "body", received: parsedBody.body })], { legacyFields: { details: parsed.error } });
         }
         const updated = updateManagedTaskRunResult(db, id, {
             lastRunAt: parsed.data.last_run_at,
             lastResult: parsed.data.last_result,
             consecutiveFailures: parsed.data.consecutive_failures,
         });
-        if (!updated)
-            return c.json({ error: "not_found" }, 404);
+        if (!updated) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("managed_tasks.not_found", { field: "id", received: id }),
+            ]);
+        }
         recordAuditAction(db, "management_task.run_recorded", {
             mt_id: id,
             // Top-level `app` / `app_normalized` for the activity-view runner
@@ -524,11 +576,16 @@ export function createManagedTasksRoutes(deps) {
     app.delete("/managed-tasks/:id", async (c) => {
         const id = c.req.param("id");
         if (!isValidManagedTaskId(id)) {
-            return c.json({ error: "invalid_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("managed_tasks.invalid_id", { field: "id", received: id }),
+            ]);
         }
         const existing = getManagedTask(db, id);
-        if (!existing)
-            return c.json({ error: "not_found" }, 404);
+        if (!existing) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("managed_tasks.not_found", { field: "id", received: id }),
+            ]);
+        }
         try {
             db.transaction(() => {
                 // §10.3 step 3a — snapshot the row into the audit detail BEFORE
@@ -554,7 +611,12 @@ export function createManagedTasksRoutes(deps) {
         }
         catch (err) {
             logger.error({ err, id }, "managed-task DELETE tx failed");
-            return c.json({ error: "internal_error" }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("managed_tasks.internal_error", {
+                    field: "tx",
+                    received: err instanceof Error ? err.message : String(err),
+                }),
+            ]);
         }
         let contextDir;
         try {
@@ -577,11 +639,16 @@ export function createManagedTasksRoutes(deps) {
     app.post("/managed-tasks/:id/run-now", async (c) => {
         const id = c.req.param("id");
         if (!isValidManagedTaskId(id)) {
-            return c.json({ error: "invalid_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("managed_tasks.invalid_id", { field: "id", received: id }),
+            ]);
         }
         const existing = getManagedTask(db, id);
-        if (!existing)
-            return c.json({ error: "not_found" }, 404);
+        if (!existing) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("managed_tasks.not_found", { field: "id", received: id }),
+            ]);
+        }
         /* c8 ignore start — readJsonBody always resolves; the .catch() fallback is unreachable */
         const parsedBody = await readJsonBody(c).catch(() => ({
             ok: true,
@@ -607,12 +674,16 @@ export function createManagedTasksRoutes(deps) {
         let scheduledRowId;
         try {
             const result = db.transaction(() => {
+                const adhocLabel = `[${id}] ad-hoc — ${existing.intent}`;
                 const insert = db
                     .prepare(`INSERT INTO agent_schedule
-                (scheduled_for, task_type, task_description, task_context,
+                (scheduled_for, task_type, task_description, task_prompt, task_context,
                  status, recurring_schedule_id, correlation_id)
-              VALUES (datetime('now'), ?, ?, ?, 'pending', ?, ?)`)
-                    .run(RUN_NOW_TASK_TYPE, `[${id}] ad-hoc — ${existing.intent}`, JSON.stringify({
+              VALUES (datetime('now'), ?, ?, ?, ?, 'pending', ?, ?)`)
+                    .run(RUN_NOW_TASK_TYPE, 
+                // task_description (label) === task_prompt (agent body); the real
+                // task is resolved from task_context.mt_id at fire time.
+                adhocLabel, adhocLabel, JSON.stringify({
                     mt_id: id,
                     app: existing.app,
                     cadence: existing.cadence,
@@ -626,7 +697,12 @@ export function createManagedTasksRoutes(deps) {
         }
         catch (err) {
             logger.error({ err, id }, "managed-task run-now enqueue failed");
-            return c.json({ error: "internal_error" }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("managed_tasks.internal_error", {
+                    field: "tx",
+                    received: err instanceof Error ? err.message : String(err),
+                }),
+            ]);
         }
         recordAuditAction(db, "management_task.run_now", {
             mt_id: id,
@@ -652,11 +728,13 @@ export function createManagedTasksRoutes(deps) {
     // `entity_source_keys` mirror) and rewrites its frontmatter
     // `sources.<oldKey>` to `sources.<newKey>`. Per-file failures are
     // isolated and surfaced in the response so the dashboard can flag
-    // them. Followups doc Issue 2 — prerequisite is now wired.
+    // them.
     app.post("/managed-tasks/:id/rename-app", async (c) => {
         const id = c.req.param("id");
         if (!isValidManagedTaskId(id)) {
-            return c.json({ error: "invalid_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("managed_tasks.invalid_id", { field: "id", received: id }),
+            ]);
         }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
@@ -665,15 +743,18 @@ export function createManagedTasksRoutes(deps) {
         if (body === null ||
             typeof body !== "object" ||
             typeof body.newApp !== "string") {
-            return c.json({ error: "validation_error", message: "body must include `newApp` string" }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("managed_tasks.validation_error", { field: "newApp", received: body })], { legacyFields: { message: "body must include `newApp` string" } });
         }
         const newAppRaw = validateAppLabel(body.newApp);
         if (newAppRaw === null) {
-            return c.json({ error: "validation_error", message: "invalid newApp" }, 400);
+            return respondWithAgentError(c, 400, [composeIssue("managed_tasks.validation_error", { field: "newApp", received: body.newApp })], { legacyFields: { message: "invalid newApp" } });
         }
         const existing = getManagedTask(db, id);
-        if (!existing)
-            return c.json({ error: "not_found" }, 404);
+        if (!existing) {
+            return respondWithAgentError(c, 404, [
+                composeIssue("managed_tasks.not_found", { field: "id", received: id }),
+            ]);
+        }
         const oldApp = existing.app;
         const oldNormalized = normalizeAppLabel(oldApp);
         const newNormalized = normalizeAppLabel(newAppRaw);
@@ -695,14 +776,25 @@ export function createManagedTasksRoutes(deps) {
              * not testable single-threaded. */
             if (message.includes("UNIQUE constraint failed: managed_tasks") ||
                 message.includes("SQLITE_CONSTRAINT_UNIQUE")) {
-                return c.json({
-                    error: "duplicate",
-                    message: "renaming would collide with an existing (app_normalized, cadence) row",
-                }, 409);
+                return respondWithAgentError(c, 409, [
+                    composeIssue("managed_tasks.duplicate", {
+                        field: "(app_normalized, cadence)",
+                        received: { newApp: newAppRaw, cadence: existing.cadence },
+                    }),
+                ], {
+                    legacyFields: {
+                        message: "renaming would collide with an existing (app_normalized, cadence) row",
+                    },
+                });
             }
             /* c8 ignore stop */
             logger.error({ err, id }, "managed-task rename-app tx failed");
-            return c.json({ error: "internal_error" }, 500);
+            return respondWithAgentError(c, 500, [
+                composeIssue("managed_tasks.internal_error", {
+                    field: "tx",
+                    received: err instanceof Error ? err.message : String(err),
+                }),
+            ]);
         }
         recordAuditAction(db, "management_task.app_renamed", {
             mt_id: id,
@@ -712,9 +804,9 @@ export function createManagedTasksRoutes(deps) {
             from: oldApp,
             to: newAppRaw,
             // `app` / `app_normalized` follow the post-rename label so the
-            // NEW `_activity/<new>.md` enumerates this event (parity with the
+            // NEW `state/activity/<new>.md` enumerates this event (parity with the
             // other `management_task.*` rows). `old_app` / `old_app_normalized`
-            // let the OLD `_activity/<old>.md` keep showing the rename for
+            // let the OLD `state/activity/<old>.md` keep showing the rename for
             // its 90-day retention window — the activity-view runner reads
             // both via the SQL OR clause in `enumerateActiveSources` /
             // `buildActivitySnapshot`.
@@ -841,4 +933,3 @@ function safeParseJson(value) {
         return value;
     }
 }
-//# sourceMappingURL=managed-tasks.js.map

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

@@ -47,4 +47,3 @@ export declare function createMcpRoutes(deps: McpRouteDependencies): Hono;
  * of the real `~`. The route always passes `homedir()`.
  */
 export declare function isGeminiInstallAlreadyApplied(kind: "google-workspace" | "notion", homeDir: string): boolean;
-//# sourceMappingURL=mcp.d.ts.map