@aitne/daemon 0.1.7 → 0.1.9

package/dist/api/routes/notion.js

@@ -1,6 +1,7 @@
 import { Hono } from "hono";
 import { createLogger, toSafeErrorMessage } from "../../logging.js";
 import { readJsonBody } from "../json-body.js";
+import { composeIssue, respondWithAgentError } from "../helpers/agent-errors.js";
 const logger = createLogger("notion-api");
 /**
  * Notion write attribution TTL — must comfortably exceed the max Notion
@@ -74,8 +75,14 @@ export function createNotionRoutes(deps) {
     // ─────────────────────────────────────────────────────────────
     app.get("/notion/databases", (c) => {
         const service = ensureService();
-        if (!service)
-            return c.json({ error: "notion_not_configured" }, 503);
+        if (!service) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("notion.not_configured", {
+                    field: "services.notion",
+                    received: "<unavailable>",
+                }),
+            ]);
+        }
         return c.json({ databases: service.listDatabases() });
     });
     // ─────────────────────────────────────────────────────────────
@@ -83,15 +90,23 @@ export function createNotionRoutes(deps) {
     // ─────────────────────────────────────────────────────────────
     app.get("/notion/query", async (c) => {
         const service = ensureService();
-        if (!service)
-            return c.json({ error: "notion_not_configured" }, 503);
+        if (!service) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("notion.not_configured", {
+                    field: "services.notion",
+                    received: "<unavailable>",
+                }),
+            ]);
+        }
         const dbLabel = c.req.query("database") ?? "tasks";
         const databaseId = service.resolveDatabaseId(dbLabel);
         if (!databaseId) {
-            return c.json({
-                error: "database_not_found",
-                available: service.listDatabases().map((d) => d.label),
-            }, 404);
+            return respondWithAgentError(c, 404, [
+                composeIssue("notion.database_not_found", {
+                    field: "database",
+                    received: dbLabel,
+                }),
+            ], { legacyFields: { available: service.listDatabases().map((d) => d.label) } });
         }
         const filterParam = c.req.query("filter");
         const sortsParam = c.req.query("sorts");
@@ -105,7 +120,16 @@ export function createNotionRoutes(deps) {
             sorts = sortsParam ? JSON.parse(sortsParam) : undefined;
         }
         catch {
-            return c.json({ error: "invalid_json_parameter", message: "filter or sorts is not valid JSON" }, 400);
+            // The catch is reachable only when at least one of filterParam /
+            // sortsParam was non-empty and failed JSON.parse. Both falsy means
+            // the try is a no-op and never throws, so a `?? "<missing>"`
+            // fallback would be dead defensive code.
+            return respondWithAgentError(c, 400, [
+                composeIssue("notion.invalid_json_parameter", {
+                    field: filterParam && !sortsParam ? "filter" : "sorts",
+                    received: filterParam ?? sortsParam,
+                }),
+            ], { legacyFields: { message: "filter or sorts is not valid JSON" } });
         }
         try {
             const result = await service.queryDatabase({
@@ -124,7 +148,12 @@ export function createNotionRoutes(deps) {
         }
         catch (err) {
             logger.error({ err, database: dbLabel }, "Notion query failed");
-            return c.json({ error: "notion_query_failed", message: toSafeErrorMessage(err) }, 502);
+            return respondWithAgentError(c, 502, [
+                composeIssue("notion.upstream_error", {
+                    field: "notion.queryDatabase",
+                    received: toSafeErrorMessage(err),
+                }),
+            ], { legacyErrorCode: "notion_query_failed", legacyFields: { message: toSafeErrorMessage(err) } });
         }
     });
     // ─────────────────────────────────────────────────────────────
@@ -132,15 +161,26 @@ export function createNotionRoutes(deps) {
     // ─────────────────────────────────────────────────────────────
     app.get("/notion/search", async (c) => {
         const service = ensureService();
-        if (!service)
-            return c.json({ error: "notion_not_configured" }, 503);
+        if (!service) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("notion.not_configured", {
+                    field: "services.notion",
+                    received: "<unavailable>",
+                }),
+            ]);
+        }
         const query = c.req.query("q") ?? undefined;
         const typeParam = c.req.query("type");
         const direction = c.req.query("sort") === "ascending" ? "ascending" : "descending";
         const pageSize = Math.min(Number(c.req.query("page_size") ?? "20"), 100);
         const startCursor = c.req.query("start_cursor");
         if (typeParam && typeParam !== "page" && typeParam !== "data_source") {
-            return c.json({ error: "invalid_type", message: "type must be 'page' or 'data_source'" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("notion.invalid_type", {
+                    field: "type",
+                    received: typeParam,
+                }),
+            ], { legacyFields: { message: "type must be 'page' or 'data_source'" } });
         }
         try {
             const result = await service.search({
@@ -158,7 +198,12 @@ export function createNotionRoutes(deps) {
         }
         catch (err) {
             logger.error({ err }, "Notion search failed");
-            return c.json({ error: "notion_search_failed", message: toSafeErrorMessage(err) }, 502);
+            return respondWithAgentError(c, 502, [
+                composeIssue("notion.upstream_error", {
+                    field: "notion.search",
+                    received: toSafeErrorMessage(err),
+                }),
+            ], { legacyErrorCode: "notion_search_failed", legacyFields: { message: toSafeErrorMessage(err) } });
         }
     });
     // ─────────────────────────────────────────────────────────────
@@ -166,11 +211,22 @@ export function createNotionRoutes(deps) {
     // ─────────────────────────────────────────────────────────────
     app.get("/notion/pages/:id", async (c) => {
         const service = ensureService();
-        if (!service)
-            return c.json({ error: "notion_not_configured" }, 503);
+        if (!service) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("notion.not_configured", {
+                    field: "services.notion",
+                    received: "<unavailable>",
+                }),
+            ]);
+        }
         const pageId = c.req.param("id");
         if (!isValidPageId(pageId)) {
-            return c.json({ error: "invalid_page_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("notion.invalid_page_id", {
+                    field: "id",
+                    received: pageId,
+                }),
+            ]);
         }
         const includeMarkdown = c.req.query("markdown") !== "false";
         const includeTranscript = c.req.query("include_transcript") === "true";
@@ -183,10 +239,20 @@ export function createNotionRoutes(deps) {
         }
         catch (err) {
             if (isNotionNotFound(err)) {
-                return c.json({ error: "not_found", pageId }, 404);
+                return respondWithAgentError(c, 404, [
+                    composeIssue("notion.not_found", {
+                        field: "pageId",
+                        received: pageId,
+                    }),
+                ], { legacyFields: { pageId } });
             }
             logger.warn({ err, pageId }, "Notion page retrieval failed");
-            return c.json({ error: "notion_get_failed", message: toSafeErrorMessage(err) }, 502);
+            return respondWithAgentError(c, 502, [
+                composeIssue("notion.upstream_error", {
+                    field: "notion.getPage",
+                    received: toSafeErrorMessage(err),
+                }),
+            ], { legacyErrorCode: "notion_get_failed", legacyFields: { message: toSafeErrorMessage(err) } });
         }
     });
     // ─────────────────────────────────────────────────────────────
@@ -194,18 +260,30 @@ export function createNotionRoutes(deps) {
     // ─────────────────────────────────────────────────────────────
     app.post("/notion/pages", async (c) => {
         const service = ensureService();
-        if (!service)
-            return c.json({ error: "notion_not_configured" }, 503);
+        if (!service) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("notion.not_configured", {
+                    field: "services.notion",
+                    received: "<unavailable>",
+                }),
+            ]);
+        }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
             return parsedBody.response;
         const body = parsedBody.body;
         const parent = resolveParent(body.parent, service);
         if (!parent) {
-            return c.json({
-                error: "invalid_parent",
-                message: "parent must be one of: a database label string, { database: 'label' }, { data_source_id: '...' }, or { page_id: '...' }",
-            }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("notion.invalid_parent", {
+                    field: "parent",
+                    received: body.parent ?? "<missing>",
+                }),
+            ], {
+                legacyFields: {
+                    message: "parent must be one of: a database label string, { database: 'label' }, { data_source_id: '...' }, or { page_id: '...' }",
+                },
+            });
         }
         return withWriteLock(async () => {
             try {
@@ -222,7 +300,12 @@ export function createNotionRoutes(deps) {
             }
             catch (err) {
                 logger.error({ err }, "Notion create page failed");
-                return c.json({ error: "notion_create_failed", message: toSafeErrorMessage(err) }, 502);
+                return respondWithAgentError(c, 502, [
+                    composeIssue("notion.upstream_error", {
+                        field: "notion.createPage",
+                        received: toSafeErrorMessage(err),
+                    }),
+                ], { legacyErrorCode: "notion_create_failed", legacyFields: { message: toSafeErrorMessage(err) } });
             }
         });
     });
@@ -231,18 +314,34 @@ export function createNotionRoutes(deps) {
     // ─────────────────────────────────────────────────────────────
     app.patch("/notion/pages/:id", async (c) => {
         const service = ensureService();
-        if (!service)
-            return c.json({ error: "notion_not_configured" }, 503);
+        if (!service) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("notion.not_configured", {
+                    field: "services.notion",
+                    received: "<unavailable>",
+                }),
+            ]);
+        }
         const pageId = c.req.param("id");
         if (!isValidPageId(pageId)) {
-            return c.json({ error: "invalid_page_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("notion.invalid_page_id", {
+                    field: "id",
+                    received: pageId,
+                }),
+            ]);
         }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
             return parsedBody.response;
         const body = parsedBody.body;
         if (Object.keys(body).length === 0) {
-            return c.json({ error: "empty_body", message: "PATCH requires at least one field to update" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("notion.empty_body", {
+                    field: "body",
+                    received: "<empty>",
+                }),
+            ], { legacyFields: { message: "PATCH requires at least one field to update" } });
         }
         return withWriteLock(async () => {
             try {
@@ -252,10 +351,20 @@ export function createNotionRoutes(deps) {
             }
             catch (err) {
                 if (isNotionNotFound(err)) {
-                    return c.json({ error: "not_found", pageId }, 404);
+                    return respondWithAgentError(c, 404, [
+                        composeIssue("notion.not_found", {
+                            field: "pageId",
+                            received: pageId,
+                        }),
+                    ], { legacyFields: { pageId } });
                 }
                 logger.error({ err, pageId }, "Notion update page failed");
-                return c.json({ error: "notion_update_failed", message: toSafeErrorMessage(err) }, 502);
+                return respondWithAgentError(c, 502, [
+                    composeIssue("notion.upstream_error", {
+                        field: "notion.updatePageProperties",
+                        received: toSafeErrorMessage(err),
+                    }),
+                ], { legacyErrorCode: "notion_update_failed", legacyFields: { message: toSafeErrorMessage(err) } });
             }
         });
     });
@@ -264,11 +373,22 @@ export function createNotionRoutes(deps) {
     // ─────────────────────────────────────────────────────────────
     app.patch("/notion/pages/:id/content", async (c) => {
         const service = ensureService();
-        if (!service)
-            return c.json({ error: "notion_not_configured" }, 503);
+        if (!service) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("notion.not_configured", {
+                    field: "services.notion",
+                    received: "<unavailable>",
+                }),
+            ]);
+        }
         const pageId = c.req.param("id");
         if (!isValidPageId(pageId)) {
-            return c.json({ error: "invalid_page_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("notion.invalid_page_id", {
+                    field: "id",
+                    received: pageId,
+                }),
+            ]);
         }
         const parsedBody = await readJsonBody(c);
         if (!parsedBody.ok)
@@ -278,19 +398,39 @@ export function createNotionRoutes(deps) {
         switch (body.mode) {
             case "append":
                 if (typeof body.content !== "string") {
-                    return c.json({ error: "content_required_for_append" }, 400);
+                    return respondWithAgentError(c, 400, [
+                        composeIssue("notion.content_required", {
+                            field: "content",
+                            received: body.content === undefined ? "<missing>" : typeof body.content,
+                            hint: "mode='append' requires `content` (string).",
+                        }),
+                    ], { legacyErrorCode: "content_required_for_append" });
                 }
                 operation = { kind: "append", content: body.content, after: body.after };
                 break;
             case "replace_all":
                 if (typeof body.content !== "string") {
-                    return c.json({ error: "content_required_for_replace_all" }, 400);
+                    return respondWithAgentError(c, 400, [
+                        composeIssue("notion.content_required", {
+                            field: "content",
+                            received: body.content === undefined ? "<missing>" : typeof body.content,
+                            hint: "mode='replace_all' requires `content` (string) to rewrite the whole page.",
+                        }),
+                    ], { legacyErrorCode: "content_required_for_replace_all" });
                 }
                 operation = { kind: "replace_all", content: body.content };
                 break;
             case "replace_range":
                 if (typeof body.content !== "string" || typeof body.contentRange !== "string") {
-                    return c.json({ error: "content_and_contentRange_required_for_replace_range" }, 400);
+                    return respondWithAgentError(c, 400, [
+                        composeIssue("notion.content_range_required", {
+                            field: "body",
+                            received: {
+                                content: body.content === undefined ? "<missing>" : typeof body.content,
+                                contentRange: body.contentRange === undefined ? "<missing>" : typeof body.contentRange,
+                            },
+                        }),
+                    ], { legacyErrorCode: "content_and_contentRange_required_for_replace_range" });
                 }
                 operation = {
                     kind: "replace_range",
@@ -301,16 +441,23 @@ export function createNotionRoutes(deps) {
                 break;
             case "update":
                 if (!Array.isArray(body.updates) || body.updates.length === 0) {
-                    return c.json({ error: "updates_required_for_update" }, 400);
+                    return respondWithAgentError(c, 400, [
+                        composeIssue("notion.updates_required", {
+                            field: "updates",
+                            received: body.updates === undefined ? "<missing>" : Array.isArray(body.updates) ? "<empty>" : typeof body.updates,
+                        }),
+                    ], { legacyErrorCode: "updates_required_for_update" });
                 }
                 for (const [i, u] of body.updates.entries()) {
                     if (typeof u?.oldStr !== "string" ||
                         typeof u?.newStr !== "string" ||
                         u.oldStr.length === 0) {
-                        return c.json({
-                            error: "updates_element_invalid",
-                            message: `updates[${i}] must have string oldStr (non-empty) and newStr`,
-                        }, 400);
+                        return respondWithAgentError(c, 400, [
+                            composeIssue("notion.updates_element_invalid", {
+                                field: `updates[${i}]`,
+                                received: u,
+                            }),
+                        ], { legacyErrorCode: "updates_element_invalid", legacyFields: { message: `updates[${i}] must have string oldStr (non-empty) and newStr` } });
                     }
                 }
                 operation = {
@@ -320,10 +467,12 @@ export function createNotionRoutes(deps) {
                 };
                 break;
             default:
-                return c.json({
-                    error: "invalid_mode",
-                    message: "mode must be 'append', 'replace_all', 'replace_range', or 'update'",
-                }, 400);
+                return respondWithAgentError(c, 400, [
+                    composeIssue("notion.invalid_mode", {
+                        field: "mode",
+                        received: body.mode ?? "<missing>",
+                    }),
+                ], { legacyFields: { message: "mode must be 'append', 'replace_all', 'replace_range', or 'update'" } });
         }
         return withWriteLock(async () => {
             try {
@@ -337,10 +486,20 @@ export function createNotionRoutes(deps) {
             }
             catch (err) {
                 if (isNotionNotFound(err)) {
-                    return c.json({ error: "not_found", pageId }, 404);
+                    return respondWithAgentError(c, 404, [
+                        composeIssue("notion.not_found", {
+                            field: "pageId",
+                            received: pageId,
+                        }),
+                    ], { legacyFields: { pageId } });
                 }
                 logger.error({ err, pageId }, "Notion content update failed");
-                return c.json({ error: "notion_content_update_failed", message: toSafeErrorMessage(err) }, 502);
+                return respondWithAgentError(c, 502, [
+                    composeIssue("notion.upstream_error", {
+                        field: "notion.updatePageContent",
+                        received: toSafeErrorMessage(err),
+                    }),
+                ], { legacyErrorCode: "notion_content_update_failed", legacyFields: { message: toSafeErrorMessage(err) } });
             }
         });
     });
@@ -349,11 +508,22 @@ export function createNotionRoutes(deps) {
     // ─────────────────────────────────────────────────────────────
     app.delete("/notion/pages/:id", async (c) => {
         const service = ensureService();
-        if (!service)
-            return c.json({ error: "notion_not_configured" }, 503);
+        if (!service) {
+            return respondWithAgentError(c, 503, [
+                composeIssue("notion.not_configured", {
+                    field: "services.notion",
+                    received: "<unavailable>",
+                }),
+            ]);
+        }
         const pageId = c.req.param("id");
         if (!isValidPageId(pageId)) {
-            return c.json({ error: "invalid_page_id" }, 400);
+            return respondWithAgentError(c, 400, [
+                composeIssue("notion.invalid_page_id", {
+                    field: "id",
+                    received: pageId,
+                }),
+            ]);
         }
         return withWriteLock(async () => {
             try {
@@ -363,10 +533,20 @@ export function createNotionRoutes(deps) {
             }
             catch (err) {
                 if (isNotionNotFound(err)) {
-                    return c.json({ error: "not_found", pageId }, 404);
+                    return respondWithAgentError(c, 404, [
+                        composeIssue("notion.not_found", {
+                            field: "pageId",
+                            received: pageId,
+                        }),
+                    ], { legacyFields: { pageId } });
                 }
                 logger.error({ err, pageId }, "Notion archive failed");
-                return c.json({ error: "notion_archive_failed", message: toSafeErrorMessage(err) }, 502);
+                return respondWithAgentError(c, 502, [
+                    composeIssue("notion.upstream_error", {
+                        field: "notion.archivePage",
+                        received: toSafeErrorMessage(err),
+                    }),
+                ], { legacyErrorCode: "notion_archive_failed", legacyFields: { message: toSafeErrorMessage(err) } });
             }
         });
     });
@@ -439,4 +619,3 @@ function resolveParent(input, service) {
     }
     return null;
 }
-//# sourceMappingURL=notion.js.map

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

@@ -1,4 +1,3 @@
 import { Hono } from "hono";
 import type { ApiDependencies } from "../server.js";
 export declare function createObservationRoutes(deps: ApiDependencies): Hono;
-//# sourceMappingURL=observations.d.ts.map