mulmoclaude 0.6.0 → 0.6.2

package/server/api/routes/photo-locations.ts

@@ -0,0 +1,79 @@
+// REST endpoint for the photo-locations plugin (#1222 PR-B).
+//
+// Single POST dispatch — same convention as accounting / scheduler.
+// LLM tool calls flow Claude → MCP → here; the View also POSTs
+// here directly for refreshes triggered by the
+// `photoLocations:locations-changed` pubsub event.
+//
+// Two kinds for v1: `list` (every sidecar, newest-first) and
+// `count` (scalar). `extractExif` and `rescan` ride a follow-up.
+
+import { Router, Request, Response } from "express";
+
+import { API_ROUTES } from "../../../src/config/apiRoutes.js";
+import { PHOTO_LOCATIONS_KINDS } from "../../../src/plugins/photoLocations/definition.js";
+import { bindRoute } from "../../utils/router.js";
+import { listAllSidecars, countAllSidecars, type ListedSidecar } from "../../workspace/photo-locations/list.js";
+import { log } from "../../system/logger/index.js";
+
+const router = Router();
+
+interface DispatchBody {
+  kind?: unknown;
+}
+
+interface DispatchToolResult {
+  kind: "photo-locations";
+  message: string;
+  data: { locations: ListedSidecar[]; total: number } | { total: number };
+}
+
+interface ErrorResponse {
+  error: string;
+}
+
+async function handleList(): Promise<DispatchToolResult> {
+  const locations = await listAllSidecars();
+  return {
+    kind: "photo-locations",
+    message: `${locations.length} captured photo location${locations.length === 1 ? "" : "s"}`,
+    data: { locations, total: locations.length },
+  };
+}
+
+async function handleCount(): Promise<DispatchToolResult> {
+  const total = await countAllSidecars();
+  return {
+    kind: "photo-locations",
+    message: `${total} captured photo location${total === 1 ? "" : "s"}`,
+    data: { total },
+  };
+}
+
+bindRoute(
+  router,
+  API_ROUTES.photoLocations.dispatch,
+  async (req: Request<object, unknown, DispatchBody>, res: Response<DispatchToolResult | ErrorResponse>) => {
+    const { kind } = req.body ?? {};
+    if (typeof kind !== "string") {
+      res.status(400).json({ error: "request body must include a string `kind` field" });
+      return;
+    }
+    try {
+      if (kind === PHOTO_LOCATIONS_KINDS.list) {
+        res.json(await handleList());
+        return;
+      }
+      if (kind === PHOTO_LOCATIONS_KINDS.count) {
+        res.json(await handleCount());
+        return;
+      }
+      res.status(400).json({ error: `unknown kind: ${kind}` });
+    } catch (err) {
+      log.error("photo-locations-route", "dispatch failed", { kind, error: String(err) });
+      res.status(500).json({ error: "internal error" });
+    }
+  },
+);
+
+export default router;

package/server/api/routes/plugins.ts

@@ -5,6 +5,7 @@ import { executeQuiz } from "@mulmochat-plugin/quiz";
 import { executeForm } from "../../../src/plugins/presentForm/plugin.js";
 import { executeOpenCanvas } from "../../../src/plugins/canvas/definition.js";
 import { executePresent3D } from "@gui-chat-plugin/present3d";
+import { executeMapControl } from "@gui-chat-plugin/google-map";
 import { errorMessage } from "../../utils/errors.js";
 import { badRequest, serverError } from "../../utils/httpError.js";
 import { saveImage } from "../../utils/files/image-store.js";
@@ -267,6 +268,16 @@ router.post(
   wrapPluginExecute((req) => executePresent3D(null as never, req.body)),
 );
 
+// mapControl — Google Map (showLocation / Places / Directions etc.)
+// from `@gui-chat-plugin/google-map`. The package's `executeMapControl`
+// returns the action descriptor; the rendered View — mounted host-side
+// from `App.vue` — performs the actual Google Maps JS calls and
+// receives the API key as a prop sourced from `AppSettings`.
+router.post(
+  API_ROUTES.plugins.googleMap,
+  wrapPluginExecute((req) => executeMapControl(null as never, req.body)),
+);
+
 // META aggregator diagnostics — boot-time host/plugin or plugin/plugin
 // key collisions. The frontend fetches this once at mount so a tab
 // that opens after the boot-time `publishNotification` fired still

package/server/api/routes/presentSvg.ts

@@ -0,0 +1,107 @@
+import { Router, Request, Response } from "express";
+import { WORKSPACE_DIRS } from "../../workspace/paths.js";
+import { writeWorkspaceText } from "../../utils/files/workspace-io.js";
+import { buildArtifactPath } from "../../utils/files/naming.js";
+import { overwriteSvg, isSvgPath } from "../../utils/files/svg-store.js";
+import { errorMessage } from "../../utils/errors.js";
+import { badRequest, serverError } from "../../utils/httpError.js";
+import { API_ROUTES } from "../../../src/config/apiRoutes.js";
+import { bindRoute } from "../../utils/router.js";
+import { log } from "../../system/logger/index.js";
+import { previewSnippet } from "../../utils/logPreview.js";
+import { publishFileChange } from "../../events/file-change.js";
+
+const router = Router();
+
+interface PresentSvgBody {
+  svg: string;
+  title?: string;
+}
+
+interface PresentSvgSuccessResponse {
+  message: string;
+  instructions: string;
+  data: { title?: string; filePath: string };
+}
+
+interface PresentSvgErrorResponse {
+  error: string;
+}
+
+type PresentSvgResponse = PresentSvgSuccessResponse | PresentSvgErrorResponse;
+
+bindRoute(router, API_ROUTES.svg.create, async (req: Request<object, unknown, PresentSvgBody>, res: Response<PresentSvgResponse>) => {
+  const { svg, title } = req.body;
+  log.info("svg", "present: start", {
+    titlePreview: typeof title === "string" ? previewSnippet(title) : undefined,
+    bytes: typeof svg === "string" ? svg.length : undefined,
+  });
+  if (!svg) {
+    log.warn("svg", "present: missing svg");
+    badRequest(res, "svg is required");
+    return;
+  }
+
+  try {
+    const filePath = buildArtifactPath(WORKSPACE_DIRS.svgs, title, ".svg", "drawing");
+    await writeWorkspaceText(filePath, svg);
+    log.info("svg", "present: ok", { filePath, bytes: svg.length });
+    void publishFileChange(filePath);
+    res.json({
+      message: `Saved SVG to ${filePath}`,
+      instructions: "Acknowledge that the SVG drawing has been presented to the user.",
+      data: { title, filePath },
+    });
+  } catch (err) {
+    log.error("svg", "present: threw", { error: errorMessage(err) });
+    serverError(res, errorMessage(err));
+  }
+});
+
+interface UpdateSvgBody {
+  relativePath: string;
+  svg: string;
+}
+
+interface UpdateSvgSuccessResponse {
+  path: string;
+}
+
+interface UpdateSvgErrorResponse {
+  error: string;
+}
+
+bindRoute(
+  router,
+  API_ROUTES.svg.update,
+  async (req: Request<object, unknown, UpdateSvgBody>, res: Response<UpdateSvgSuccessResponse | UpdateSvgErrorResponse>) => {
+    const { relativePath, svg } = req.body;
+    log.info("svg", "update: start", {
+      pathPreview: typeof relativePath === "string" ? previewSnippet(relativePath) : undefined,
+      bytes: typeof svg === "string" ? svg.length : undefined,
+    });
+    if (!svg) {
+      log.warn("svg", "update: missing svg");
+      badRequest(res, "svg is required");
+      return;
+    }
+    if (!relativePath || !isSvgPath(relativePath)) {
+      log.warn("svg", "update: invalid relativePath", {
+        pathPreview: typeof relativePath === "string" ? previewSnippet(relativePath) : undefined,
+      });
+      badRequest(res, "invalid svg relativePath");
+      return;
+    }
+    try {
+      await overwriteSvg(relativePath, svg);
+      log.info("svg", "update: ok", { pathPreview: previewSnippet(relativePath), bytes: svg.length });
+      void publishFileChange(relativePath);
+      res.json({ path: relativePath });
+    } catch (err) {
+      log.error("svg", "update: threw", { pathPreview: previewSnippet(relativePath), error: errorMessage(err) });
+      serverError(res, errorMessage(err));
+    }
+  },
+);
+
+export default router;

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;