mulmoclaude 0.6.1 → 0.6.2

package/server/api/routes/scheduler.ts

@@ -10,8 +10,8 @@ import { saveUserTasks } from "../../utils/files/user-tasks-io.js";
 import { startChat } from "./agent.js";
 import { log } from "../../system/logger/index.js";
 import { SCHEDULER_ACTIONS, TASK_ACTIONS } from "../../../src/plugins/scheduler/actions.js";
-import { badRequest, notFound, serverError } from "../../utils/httpError.js";
-import { errorMessage } from "../../utils/errors.js";
+import { badRequest, notFound } from "../../utils/httpError.js";
+import { asyncHandler } from "../../utils/asyncHandler.js";
 import { makeUuid } from "../../utils/id.js";
 
 const router = Router();
@@ -47,118 +47,120 @@ interface SchedulerBody extends SchedulerActionInput {
 bindRoute(
   router,
   API_ROUTES.scheduler.dispatch,
-  async (req: Request<object, unknown, SchedulerBody>, res: Response<DispatchSuccessResponse<ScheduledItem> | DispatchErrorResponse | unknown>) => {
-    const { action, ...input } = req.body;
+  asyncHandler<Request<object, unknown, SchedulerBody>, Response<DispatchSuccessResponse<ScheduledItem> | DispatchErrorResponse | unknown>>(
+    "scheduler",
+    "Internal server error",
+    async (req, res) => {
+      const { action, ...input } = req.body;
 
-    // Route task actions to the user-task subsystem
-    if (TASK_ACTIONS.has(action)) {
-      await handleTaskAction(action, input, res);
-      return;
-    }
+      // Route task actions to the user-task subsystem
+      if (TASK_ACTIONS.has(action)) {
+        await handleTaskAction(action, input, res);
+        return;
+      }
 
-    // Calendar item actions (existing behavior)
-    const items = loadItems();
-    const result = dispatchScheduler(action, items, input);
-    respondWithDispatchResult(res, result, {
-      shouldPersist: action !== SCHEDULER_ACTIONS.show,
-      instructions: "Display the updated scheduler to the user.",
-      persist: saveItems,
-    });
-  },
+      // Calendar item actions (existing behavior)
+      const items = loadItems();
+      const result = dispatchScheduler(action, items, input);
+      respondWithDispatchResult(res, result, {
+        shouldPersist: action !== SCHEDULER_ACTIONS.show,
+        instructions: "Display the updated scheduler to the user.",
+        persist: saveItems,
+      });
+    },
+  ),
 );
 
 async function handleTaskAction(action: string, input: Record<string, unknown>, res: Response): Promise<void> {
   log.info("scheduler", "task action: start", { action });
-  try {
-    if (action === SCHEDULER_ACTIONS.listTasks) {
-      const tasks = loadUserTasks();
-      log.info("scheduler", "task action: listTasks ok", { tasks: tasks.length });
-      res.json({
-        uuid: makeUuid(),
-        message: `${tasks.length} scheduled task(s) found.`,
-        data: { tasks },
-      });
-      return;
-    }
+  // Errors bubble up to the asyncHandler wrapper on the dispatch route,
+  // which logs at `log.error("scheduler", "handler threw", …)` and
+  // returns a generic 500. No inner try/catch needed here.
+  if (action === SCHEDULER_ACTIONS.listTasks) {
+    const tasks = loadUserTasks();
+    log.info("scheduler", "task action: listTasks ok", { tasks: tasks.length });
+    res.json({
+      uuid: makeUuid(),
+      message: `${tasks.length} scheduled task(s) found.`,
+      data: { tasks },
+    });
+    return;
+  }
 
-    if (action === SCHEDULER_ACTIONS.createTask) {
-      const result = validateAndCreate(input);
-      if (result.kind === "error") {
-        log.warn("scheduler", "task action: createTask validation failed", { error: result.error });
-        badRequest(res, result.error);
-        return;
-      }
-      const tasks = loadUserTasks();
-      tasks.push(result.task);
-      await saveUserTasks(tasks);
-      await refreshUserTasks();
-      log.info("scheduler", "task action: createTask ok", { id: result.task.id, name: result.task.name });
-      res.json({
-        uuid: makeUuid(),
-        message: `Task "${result.task.name}" created and scheduled.`,
-        data: { task: result.task },
-      });
+  if (action === SCHEDULER_ACTIONS.createTask) {
+    const result = validateAndCreate(input);
+    if (result.kind === "error") {
+      log.warn("scheduler", "task action: createTask validation failed", { error: result.error });
+      badRequest(res, result.error);
       return;
     }
+    const tasks = loadUserTasks();
+    tasks.push(result.task);
+    await saveUserTasks(tasks);
+    await refreshUserTasks();
+    log.info("scheduler", "task action: createTask ok", { id: result.task.id, name: result.task.name });
+    res.json({
+      uuid: makeUuid(),
+      message: `Task "${result.task.name}" created and scheduled.`,
+      data: { task: result.task },
+    });
+    return;
+  }
 
-    if (action === SCHEDULER_ACTIONS.deleteTask) {
-      const taskId = typeof input.id === "string" ? input.id : "";
-      const tasks = loadUserTasks();
-      const idx = tasks.findIndex((task) => task.id === taskId);
-      if (idx === -1) {
-        log.warn("scheduler", "task action: deleteTask not found", { taskId });
-        notFound(res, `task not found: ${taskId}`);
-        return;
-      }
-      const { name } = tasks[idx];
-      tasks.splice(idx, 1);
-      await saveUserTasks(tasks);
-      await refreshUserTasks();
-      log.info("scheduler", "task action: deleteTask ok", { taskId, name });
-      res.json({
-        uuid: makeUuid(),
-        message: `Task "${name}" deleted.`,
-        data: { deleted: taskId },
-      });
+  if (action === SCHEDULER_ACTIONS.deleteTask) {
+    const taskId = typeof input.id === "string" ? input.id : "";
+    const tasks = loadUserTasks();
+    const idx = tasks.findIndex((task) => task.id === taskId);
+    if (idx === -1) {
+      log.warn("scheduler", "task action: deleteTask not found", { taskId });
+      notFound(res, `task not found: ${taskId}`);
       return;
     }
+    const { name } = tasks[idx];
+    tasks.splice(idx, 1);
+    await saveUserTasks(tasks);
+    await refreshUserTasks();
+    log.info("scheduler", "task action: deleteTask ok", { taskId, name });
+    res.json({
+      uuid: makeUuid(),
+      message: `Task "${name}" deleted.`,
+      data: { deleted: taskId },
+    });
+    return;
+  }
 
-    if (action === SCHEDULER_ACTIONS.runTask) {
-      const taskId = typeof input.id === "string" ? input.id : "";
-      const tasks = loadUserTasks();
-      const task = tasks.find((candidate) => candidate.id === taskId);
-      if (!task) {
-        notFound(res, `task not found: ${taskId}`);
-        return;
-      }
-      const chatSessionId = makeUuid();
-      log.info("scheduler", "manual run via MCP", {
-        name: task.name,
-        chatSessionId,
-      });
-      startChat({
-        message: task.prompt,
-        roleId: task.roleId,
-        chatSessionId,
-        origin: SESSION_ORIGINS.scheduler,
-      }).catch((err) => {
-        log.error("scheduler", "manual run failed", {
-          error: String(err),
-        });
-      });
-      res.json({
-        uuid: makeUuid(),
-        message: `Task "${task.name}" triggered.`,
-        data: { triggered: taskId, chatSessionId },
-      });
+  if (action === SCHEDULER_ACTIONS.runTask) {
+    const taskId = typeof input.id === "string" ? input.id : "";
+    const tasks = loadUserTasks();
+    const task = tasks.find((candidate) => candidate.id === taskId);
+    if (!task) {
+      notFound(res, `task not found: ${taskId}`);
       return;
     }
-
-    badRequest(res, `unknown task action: ${action}`);
-  } catch (err) {
-    log.error("scheduler", "task action failed", { error: errorMessage(err) });
-    serverError(res, "Internal server error");
+    const chatSessionId = makeUuid();
+    log.info("scheduler", "manual run via MCP", {
+      name: task.name,
+      chatSessionId,
+    });
+    startChat({
+      message: task.prompt,
+      roleId: task.roleId,
+      chatSessionId,
+      origin: SESSION_ORIGINS.scheduler,
+    }).catch((err) => {
+      log.error("scheduler", "manual run failed", {
+        error: String(err),
+      });
+    });
+    res.json({
+      uuid: makeUuid(),
+      message: `Task "${task.name}" triggered.`,
+      data: { triggered: taskId, chatSessionId },
+    });
+    return;
   }
+
+  badRequest(res, `unknown task action: ${action}`);
 }
 
 export default router;

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;