mulmoclaude 0.6.0 → 0.6.2

package/server/api/routes/schedulerTasks.ts

@@ -14,20 +14,23 @@ import { API_ROUTES } from "../../../src/config/apiRoutes.js";
 import { bindRoute } from "../../utils/router.js";
 import { SESSION_ORIGINS } from "../../../src/types/session.js";
 import { loadUserTasks, validateAndCreate, applyUpdate, withUserTaskLock } from "../../workspace/skills/user-tasks.js";
-import { badRequest, notFound, serverError } from "../../utils/httpError.js";
+import { badRequest, notFound } from "../../utils/httpError.js";
 import { errorMessage } from "../../utils/errors.js";
 import { getOptionalStringQuery } from "../../utils/request.js";
 import { log } from "../../system/logger/index.js";
 import { startChat } from "./agent.js";
 import { makeUuid } from "../../utils/id.js";
+import { asyncHandler } from "../../utils/asyncHandler.js";
 
 const router = Router();
 
 // ── List all tasks ──────────────────────────────────────────────
 
-bindRoute(router, API_ROUTES.scheduler.tasksList, (_req: Request, res: Response) => {
-  log.info("scheduler-tasks", "list: start");
-  try {
+bindRoute(
+  router,
+  API_ROUTES.scheduler.tasksList,
+  asyncHandler("scheduler-tasks", "Failed to list tasks", async (_req, res) => {
+    log.info("scheduler-tasks", "list: start");
     // getSchedulerTasks() returns system-only tasks (registered via
     // initScheduler at startup — journal, chat-index, sources, etc.).
     // origin: "system" is correct, not an overwrite — these tasks
@@ -37,95 +40,92 @@ bindRoute(router, API_ROUTES.scheduler.tasksList, (_req: Request, res: Response)
     const all = [...systemTasks.map((task) => ({ ...task, origin: "system" as const })), ...userTasks.map((task) => ({ ...task, origin: "user" as const }))];
     log.info("scheduler-tasks", "list: ok", { system: systemTasks.length, user: userTasks.length });
     res.json({ tasks: all });
-  } catch (err) {
-    // loadUserTasks reads JSON from disk and getSchedulerTasks
-    // queries the in-memory registry — neither is supposed to
-    // throw, but a corrupted user-tasks.json or an early-startup
-    // registry race would. Without the catch the route would 500
-    // with no trace, which is the original #779 complaint pattern.
-    log.error("scheduler-tasks", "list: failed", { error: errorMessage(err) });
-    serverError(res, "Failed to list tasks");
-  }
-});
+  }),
+);
 
 // ── Create user task ────────────────────────────────────────────
 
-bindRoute(router, API_ROUTES.scheduler.tasksCreate, async (req: Request, res: Response) => {
-  log.info("scheduler-tasks", "create: start");
-  const validated = validateAndCreate(req.body);
-  if (validated.kind === "error") {
-    log.warn("scheduler-tasks", "create: validation failed", { error: validated.error });
-    badRequest(res, validated.error);
-    return;
-  }
-  try {
+bindRoute(
+  router,
+  API_ROUTES.scheduler.tasksCreate,
+  asyncHandler("scheduler-tasks", "Failed to create task", async (req, res) => {
+    log.info("scheduler-tasks", "create: start");
+    const validated = validateAndCreate(req.body);
+    if (validated.kind === "error") {
+      log.warn("scheduler-tasks", "create: validation failed", { error: validated.error });
+      badRequest(res, validated.error);
+      return;
+    }
     const task = await withUserTaskLock(async (tasks) => ({
       tasks: [...tasks, validated.task],
       result: validated.task,
     }));
     log.info("scheduler-tasks", "create: ok", { id: task.id, name: task.name });
     res.status(201).json({ task });
-  } catch (err) {
-    log.error("scheduler-tasks", "create: failed", {
-      error: String(err),
-    });
-    serverError(res, "Failed to create task");
-  }
-});
+  }),
+);
 
 // ── Update user task ────────────────────────────────────────────
 
-bindRoute(router, API_ROUTES.scheduler.taskUpdate, async (req: Request<{ id: string }>, res: Response) => {
-  const { id: taskId } = req.params;
-  log.info("scheduler-tasks", "update: start", { taskId });
-  try {
-    const updated = await withUserTaskLock(async (tasks) => {
-      const result = applyUpdate(tasks, taskId, req.body);
-      if (result.kind === "error") {
-        throw new Error(result.error);
+bindRoute(
+  router,
+  API_ROUTES.scheduler.taskUpdate,
+  asyncHandler<Request<{ id: string }>, Response>("scheduler-tasks", "Failed to update task", async (req, res) => {
+    const { id: taskId } = req.params;
+    log.info("scheduler-tasks", "update: start", { taskId });
+    try {
+      const updated = await withUserTaskLock(async (tasks) => {
+        const result = applyUpdate(tasks, taskId, req.body);
+        if (result.kind === "error") {
+          throw new Error(result.error);
+        }
+        const task = result.tasks.find((taskItem) => taskItem.id === taskId);
+        return { tasks: result.tasks, result: task };
+      });
+      log.info("scheduler-tasks", "update: ok", { taskId });
+      res.json({ task: updated });
+    } catch (err) {
+      // Domain-shaped errors → 404; everything else rethrows for the
+      // asyncHandler wrapper to surface as 500.
+      const msg = errorMessage(err);
+      if (msg.startsWith("task not found") || msg.startsWith("request body")) {
+        log.warn("scheduler-tasks", "update: validation failed", { taskId, reason: msg });
+        notFound(res, msg);
+        return;
       }
-      const task = result.tasks.find((taskItem) => taskItem.id === taskId);
-      return { tasks: result.tasks, result: task };
-    });
-    log.info("scheduler-tasks", "update: ok", { taskId });
-    res.json({ task: updated });
-  } catch (err) {
-    const msg = errorMessage(err);
-    if (msg.startsWith("task not found") || msg.startsWith("request body")) {
-      log.warn("scheduler-tasks", "update: validation failed", { taskId, reason: msg });
-      notFound(res, msg);
-      return;
+      throw err;
     }
-    log.error("scheduler-tasks", "update: failed", { taskId, error: msg });
-    serverError(res, "Failed to update task");
-  }
-});
+  }),
+);
 
 // ── Delete user task ────────────────────────────────────────────
 
-bindRoute(router, API_ROUTES.scheduler.taskDelete, async (req: Request<{ id: string }>, res: Response) => {
-  const { id: taskId } = req.params;
-  log.info("scheduler-tasks", "delete: start", { taskId });
-  try {
-    await withUserTaskLock(async (tasks) => {
-      const index = tasks.findIndex((task) => task.id === taskId);
-      if (index === -1) throw new Error(`task not found: ${taskId}`);
-      const next = tasks.filter((task) => task.id !== taskId);
-      return { tasks: next, result: undefined };
-    });
-    log.info("scheduler-tasks", "delete: ok", { taskId });
-    res.json({ deleted: taskId });
-  } catch (err) {
-    const msg = errorMessage(err);
-    if (msg.startsWith("task not found")) {
-      log.warn("scheduler-tasks", "delete: not found", { taskId });
-      notFound(res, msg);
-      return;
+bindRoute(
+  router,
+  API_ROUTES.scheduler.taskDelete,
+  asyncHandler<Request<{ id: string }>, Response>("scheduler-tasks", "Failed to delete task", async (req, res) => {
+    const { id: taskId } = req.params;
+    log.info("scheduler-tasks", "delete: start", { taskId });
+    try {
+      await withUserTaskLock(async (tasks) => {
+        const index = tasks.findIndex((task) => task.id === taskId);
+        if (index === -1) throw new Error(`task not found: ${taskId}`);
+        const next = tasks.filter((task) => task.id !== taskId);
+        return { tasks: next, result: undefined };
+      });
+      log.info("scheduler-tasks", "delete: ok", { taskId });
+      res.json({ deleted: taskId });
+    } catch (err) {
+      const msg = errorMessage(err);
+      if (msg.startsWith("task not found")) {
+        log.warn("scheduler-tasks", "delete: not found", { taskId });
+        notFound(res, msg);
+        return;
+      }
+      throw err;
     }
-    log.error("scheduler-tasks", "delete: failed", { taskId, error: msg });
-    serverError(res, "Failed to delete task");
-  }
-});
+  }),
+);
 
 // ── Manual trigger ──────────────────────────────────────────────
 
@@ -177,25 +177,28 @@ interface LogQuery {
   limit?: string;
 }
 
-bindRoute(router, API_ROUTES.scheduler.logs, async (req: Request<object, unknown, object, LogQuery>, res: Response<{ logs: TaskLogEntry[] }>) => {
-  const MAX_LIMIT = 500;
-  const rawLimitStr = getOptionalStringQuery(req, "limit");
-  const rawLimit = rawLimitStr ? parseInt(rawLimitStr, 10) : undefined;
-  const limit = rawLimit !== undefined && Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, MAX_LIMIT) : undefined;
-  const taskId = getOptionalStringQuery(req, "taskId");
-  log.info("scheduler-tasks", "logs: start", { taskId, limit });
-  try {
-    const logs = await getSchedulerLogs({
-      since: getOptionalStringQuery(req, "since"),
-      taskId,
-      limit,
-    });
-    log.info("scheduler-tasks", "logs: ok", { entries: logs.length, taskId });
-    res.json({ logs });
-  } catch (err) {
-    log.error("scheduler-tasks", "logs: failed", { taskId, error: errorMessage(err) });
-    serverError(res, "Failed to read scheduler logs");
-  }
-});
+bindRoute(
+  router,
+  API_ROUTES.scheduler.logs,
+  asyncHandler<Request<object, unknown, object, LogQuery>, Response<{ logs: TaskLogEntry[] }>>(
+    "scheduler-tasks",
+    "Failed to read scheduler logs",
+    async (req, res) => {
+      const MAX_LIMIT = 500;
+      const rawLimitStr = getOptionalStringQuery(req, "limit");
+      const rawLimit = rawLimitStr ? parseInt(rawLimitStr, 10) : undefined;
+      const limit = rawLimit !== undefined && Number.isFinite(rawLimit) && rawLimit > 0 ? Math.min(rawLimit, MAX_LIMIT) : undefined;
+      const taskId = getOptionalStringQuery(req, "taskId");
+      log.info("scheduler-tasks", "logs: start", { taskId, limit });
+      const logs = await getSchedulerLogs({
+        since: getOptionalStringQuery(req, "since"),
+        taskId,
+        limit,
+      });
+      log.info("scheduler-tasks", "logs: ok", { entries: logs.length, taskId });
+      res.json({ logs });
+    },
+  ),
+);
 
 export default router;

package/server/api/routes/sessions.ts

@@ -25,6 +25,7 @@ import { ONE_DAY_MS } from "../../utils/time.js";
 import { encodeCursor, parseCursor, sessionChangeMs } from "./sessionsCursor.js";
 import { errorMessage } from "../../utils/errors.js";
 import { log } from "../../system/logger/index.js";
+import { asyncHandler } from "../../utils/asyncHandler.js";
 
 interface SessionMeta {
   roleId: string;
@@ -355,14 +356,13 @@ router.post(API_ROUTES.sessions.markRead, async (req: Request<SessionIdParams>,
 // Toggle the user-set bookmark flag on a session's meta sidecar.
 router.post(
   API_ROUTES.sessions.bookmark,
-  async (
-    req: Request<SessionIdParams, { ok: boolean } | SessionErrorResponse, { bookmarked: boolean }>,
-    res: Response<{ ok: boolean } | SessionErrorResponse>,
-  ) => {
-    const { id: sessionId } = req.params;
-    const bookmarked = Boolean(req.body?.bookmarked);
-    log.info("sessions", "bookmark: start", { sessionId, bookmarked });
-    try {
+  asyncHandler<Request<SessionIdParams, { ok: boolean } | SessionErrorResponse, { bookmarked: boolean }>, Response<{ ok: boolean } | SessionErrorResponse>>(
+    "sessions",
+    "Failed to update bookmark",
+    async (req, res) => {
+      const { id: sessionId } = req.params;
+      const bookmarked = Boolean(req.body?.bookmarked);
+      log.info("sessions", "bookmark: start", { sessionId, bookmarked });
       await updateIsBookmarked(sessionId, bookmarked);
       // Meta-mtime bumps on the write — cursor diff will pick up the
       // change on the next refetch — but every other tab also needs
@@ -370,11 +370,8 @@ router.post(
       publishSessionsChanged();
       log.info("sessions", "bookmark: ok", { sessionId, bookmarked });
       res.json({ ok: true });
-    } catch (err) {
-      log.error("sessions", "bookmark: threw", { sessionId, error: errorMessage(err) });
-      res.status(500).json({ error: "Failed to update bookmark" });
-    }
-  },
+    },
+  ),
 );
 
 // Hard-delete a session: remove the jsonl, meta sidecar, AND the
@@ -395,24 +392,22 @@ router.post(
 //   3. Only after disk is clean do we evict from the store and fire
 //      `notifySessionsChanged({ deletedIds })`. Now the broadcast is
 //      a truthful statement.
-router.delete(API_ROUTES.sessions.detail, async (req: Request<SessionIdParams>, res: Response<{ ok: boolean } | SessionErrorResponse>) => {
-  const { id: sessionId } = req.params;
-  log.info("sessions", "delete: start", { sessionId });
-  if (getSession(sessionId)?.isRunning) {
-    log.warn("sessions", "delete: refused — session running", { sessionId });
-    res.status(409).json({ error: "Session is running. Cancel the run before deleting." });
-    return;
-  }
-  try {
+router.delete(
+  API_ROUTES.sessions.detail,
+  asyncHandler<Request<SessionIdParams>, Response<{ ok: boolean } | SessionErrorResponse>>("sessions", "Failed to delete session", async (req, res) => {
+    const { id: sessionId } = req.params;
+    log.info("sessions", "delete: start", { sessionId });
+    if (getSession(sessionId)?.isRunning) {
+      log.warn("sessions", "delete: refused — session running", { sessionId });
+      res.status(409).json({ error: "Session is running. Cancel the run before deleting." });
+      return;
+    }
     await deleteSessionFiles(sessionId);
     await removeSessionFromIndex(workspacePath, sessionId);
     evictSession(sessionId);
     log.info("sessions", "delete: ok", { sessionId });
     res.json({ ok: true });
-  } catch (err) {
-    log.error("sessions", "delete: threw", { sessionId, error: errorMessage(err) });
-    res.status(500).json({ error: "Failed to delete session" });
-  }
-});
+  }),
+);
 
 export default router;

package/server/api/routes/sources.ts

@@ -36,6 +36,7 @@ import { badRequest, conflict, sendError, serverError } from "../../utils/httpEr
 import { errorMessage } from "../../utils/errors.js";
 import { API_ROUTES } from "../../../src/config/apiRoutes.js";
 import { bindRoute } from "../../utils/router.js";
+import { asyncHandler } from "../../utils/asyncHandler.js";
 import { isNonEmptyString, isRecord } from "../../utils/types.js";
 
 const router = Router();
@@ -56,15 +57,14 @@ interface ErrorResponse {
   error: string;
 }
 
-bindRoute(router, API_ROUTES.sources.list, async (_req: Request, res: Response<ListSourcesResponse | ErrorResponse>) => {
-  try {
+bindRoute(
+  router,
+  API_ROUTES.sources.list,
+  asyncHandler<Request, Response<ListSourcesResponse | ErrorResponse>>("sources", "failed to list sources", async (_req, res) => {
     const sources = await listSources(workspacePath);
     res.json({ sources });
-  } catch (err) {
-    log.warn("sources", "list failed", { error: String(err) });
-    serverError(res, errorMessage(err, "unknown error"));
-  }
-});
+  }),
+);
 
 // --- POST /api/sources --------------------------------------------------
 
@@ -164,13 +164,15 @@ interface RebuildBody {
   scheduleType?: unknown;
 }
 
-bindRoute(router, API_ROUTES.sources.rebuild, async (req: Request<object, unknown, RebuildBody>, res: Response<ErrorResponse | Record<string, unknown>>) => {
-  const scheduleType = validateSchedule(req.body?.scheduleType, "daily");
-  if (!scheduleType) {
-    badRequest(res, `scheduleType must be one of: ${[...SOURCE_SCHEDULES].join(", ")}`);
-    return;
-  }
-  try {
+bindRoute(
+  router,
+  API_ROUTES.sources.rebuild,
+  asyncHandler<Request<object, unknown, RebuildBody>, Response<ErrorResponse | Record<string, unknown>>>("sources", "rebuild failed", async (req, res) => {
+    const scheduleType = validateSchedule(req.body?.scheduleType, "daily");
+    if (!scheduleType) {
+      badRequest(res, `scheduleType must be one of: ${[...SOURCE_SCHEDULES].join(", ")}`);
+      return;
+    }
     log.info("sources", "manual rebuild triggered", { scheduleType });
     const result = await runSourcesPipeline({
       workspaceRoot: workspacePath,
@@ -196,11 +198,8 @@ bindRoute(router, API_ROUTES.sources.rebuild, async (req: Request<object, unknow
       archiveErrors: result.archiveErrors,
       isoDate: result.isoDate,
     });
-  } catch (err) {
-    log.warn("sources", "rebuild failed", { error: String(err) });
-    serverError(res, errorMessage(err, "rebuild failed"));
-  }
-});
+  }),
+);
 
 // --- POST /api/sources/manage -------------------------------------------
 //
@@ -244,31 +243,34 @@ interface ManageSourceSuccess {
 
 const MANAGE_ACTIONS = new Set(["list", "register", "remove", "rebuild"]);
 
-bindRoute(router, API_ROUTES.sources.manage, async (req: Request<object, unknown, ManageSourceBody>, res: Response<ManageSourceSuccess | ErrorResponse>) => {
-  const action = req.body?.action;
-  if (typeof action !== "string" || !MANAGE_ACTIONS.has(action)) {
-    badRequest(res, `action must be one of: ${[...MANAGE_ACTIONS].join(", ")}`);
-    return;
-  }
-  try {
-    switch (action) {
-      case "list":
-        await respondWithList(res, "Loaded source registry.");
-        return;
-      case "register":
-        await handleRegister(req.body, res);
-        return;
-      case "remove":
-        await handleRemove(req.body, res);
+bindRoute(
+  router,
+  API_ROUTES.sources.manage,
+  asyncHandler<Request<object, unknown, ManageSourceBody>, Response<ManageSourceSuccess | ErrorResponse>>(
+    "sources",
+    "manageSource dispatch failed",
+    async (req, res) => {
+      const action = req.body?.action;
+      if (typeof action !== "string" || !MANAGE_ACTIONS.has(action)) {
+        badRequest(res, `action must be one of: ${[...MANAGE_ACTIONS].join(", ")}`);
         return;
-      case "rebuild":
-        await handleRebuild(res);
-    }
-  } catch (err) {
-    log.warn("sources", "manage failed", { action, error: String(err) });
-    serverError(res, errorMessage(err, "manage failed"));
-  }
-});
+      }
+      switch (action) {
+        case "list":
+          await respondWithList(res, "Loaded source registry.");
+          return;
+        case "register":
+          await handleRegister(req.body, res);
+          return;
+        case "remove":
+          await handleRemove(req.body, res);
+          return;
+        case "rebuild":
+          await handleRebuild(res);
+      }
+    },
+  ),
+);
 
 async function respondWithList(res: Response<ManageSourceSuccess | ErrorResponse>, message: string, extra: Partial<ManageSourceData> = {}): Promise<void> {
   const sources = await listSources(workspacePath);

package/server/api/routes/wiki/history.ts

@@ -7,9 +7,9 @@
 //     itself, so undo stays cheap).
 //
 // Path safety: both `:slug` and `:stamp` are validated *before*
-// they are joined with the workspace root. The slug check matches
-// `wiki-pages/io.ts`'s `isSafeSlug`; the stamp check is the
-// `FILENAME_RE` shape exposed via `isSafeStamp`.
+// they are joined with the workspace root. The slug check is the
+// shared `isSafeSlug` from `src/lib/wiki-page/slug.ts`; the stamp
+// check is the `FILENAME_RE` shape exposed via `isSafeStamp`.
 
 import { Router, type Request, type Response } from "express";
 import path from "node:path";
@@ -24,20 +24,11 @@ import { readTextOrNull } from "../../../utils/files/safe.js";
 import { workspacePath } from "../../../workspace/workspace.js";
 import { pushToolResult } from "../../../events/session-store/index.js";
 import { log } from "../../../system/logger/index.js";
+import { errorMessage } from "../../../utils/errors.js";
+import { isSafeSlug } from "../../../../src/lib/wiki-page/slug.js";
 
 const router = Router();
 
-// Mirrors `isSafeSlug` from wiki-pages/io.ts (kept independent so
-// the route layer doesn't import the helper through a circular
-// dependency — io.ts already imports snapshot.ts).
-function isSafeSlug(slug: string): boolean {
-  if (slug.length === 0) return false;
-  if (slug === "." || slug === "..") return false;
-  if (slug.includes("/") || slug.includes("\\")) return false;
-  if (slug.includes("\0")) return false;
-  return true;
-}
-
 // Restore is a write under the user's workspace; record a short
 // reason on the new snapshot so the history reads "Restored from
 // 2026-04-28T01-23-45-789Z" rather than an empty cell. Editor stays
@@ -250,7 +241,7 @@ router.post("/internal/snapshot", async (req: Request<object, unknown, InternalS
     } catch (err) {
       log.warn("wiki", "page-edit toolResult publish failed", {
         slug,
-        error: err instanceof Error ? err.message : String(err),
+        error: errorMessage(err),
       });
     }
   }