mulmoclaude 0.1.0

package/server/api/routes/chat-index.ts

@@ -0,0 +1,46 @@
+// Debug trigger endpoint for the chat indexer. The normal path is
+// the agent `finally` hook in server/routes/agent.ts — one session
+// at a time, with a 15-minute freshness throttle. This endpoint
+// exists so the user can force-rebuild every session's summary on
+// demand without restarting the server, which is useful for
+// testing the feature against an existing workspace full of
+// never-indexed sessions.
+//
+// Usage:
+//   curl -X POST http://localhost:3000/api/chat-index/rebuild
+
+import { Router, Request, Response } from "express";
+import { backfillAllSessions } from "../../workspace/chat-index/index.js";
+import { log } from "../../system/logger/index.js";
+import { serverError } from "../../utils/httpError.js";
+import { API_ROUTES } from "../../../src/config/apiRoutes.js";
+
+interface RebuildResponse {
+  total: number;
+  indexed: number;
+  skipped: number;
+}
+
+interface RebuildErrorResponse {
+  error: string;
+}
+
+const router = Router();
+
+router.post(API_ROUTES.chatIndex.rebuild, async (_req: Request, res: Response<RebuildResponse | RebuildErrorResponse>) => {
+  try {
+    log.info("chat-index", "manual rebuild triggered");
+    const result = await backfillAllSessions();
+    log.info("chat-index", "rebuild complete", {
+      indexed: result.indexed,
+      total: result.total,
+      skipped: result.skipped,
+    });
+    res.json(result);
+  } catch (err) {
+    log.warn("chat-index", "rebuild failed", { error: String(err) });
+    serverError(res, err instanceof Error ? err.message : "unknown error");
+  }
+});
+
+export default router;

package/server/api/routes/config.ts

@@ -0,0 +1,258 @@
+import { Router, type Request, type Response } from "express";
+import {
+  fromMcpEntries,
+  isAppSettings,
+  loadMcpConfig,
+  loadSettings,
+  saveMcpConfig,
+  saveSettings,
+  toMcpEntries,
+  type AppSettings,
+  type McpConfigFile,
+  type McpServerEntry,
+} from "../../system/config.js";
+import { badRequest, serverError } from "../../utils/httpError.js";
+import { isRecord } from "../../utils/types.js";
+import { API_ROUTES } from "../../../src/config/apiRoutes.js";
+import { loadCustomDirs, saveCustomDirs, ensureCustomDirs, validateCustomDirs, type CustomDirEntry } from "../../workspace/custom-dirs.js";
+import { loadReferenceDirs, saveReferenceDirs, validateReferenceDirs, type ReferenceDirEntry } from "../../workspace/reference-dirs.js";
+
+// Public surface of /api/config. GET returns the full config tree so
+// the client can render every section in one request. PUT surfaces are
+// per-section to keep payloads small and validation obvious.
+export interface ConfigResponse {
+  settings: AppSettings;
+  mcp: { servers: McpServerEntry[] };
+}
+
+export interface ConfigErrorResponse {
+  error: string;
+}
+
+type ConfigRes = Response<ConfigResponse | ConfigErrorResponse>;
+
+function buildFullResponse(): ConfigResponse {
+  return {
+    settings: loadSettings(),
+    mcp: { servers: toMcpEntries(loadMcpConfig()) },
+  };
+}
+
+function isMcpPutBody(value: unknown): value is { servers: McpServerEntry[] } {
+  if (!isRecord(value)) return false;
+  if (!Array.isArray(value.servers)) return false;
+  // Full shape validation happens inside fromMcpEntries (throws on
+  // anything malformed). Here we just confirm the envelope.
+  return value.servers.every((e) => isRecord(e) && "id" in e && "spec" in e);
+}
+
+// Parse an MCP payload through `fromMcpEntries` (which does the full
+// shape validation and throws on anything malformed). On failure,
+// respond 400 and return null so the caller can early-return.
+function parseMcpPayloadOrFail(res: ConfigRes, servers: McpServerEntry[]): McpConfigFile | null {
+  try {
+    return fromMcpEntries(servers);
+  } catch (err) {
+    badRequest(res, err instanceof Error ? err.message : "invalid mcp entries");
+    return null;
+  }
+}
+
+// Run a filesystem save. On failure, respond 500 with the error's
+// message and return false so the caller can early-return. Returns
+// true on success.
+function runSaveOrFail(res: ConfigRes, save: () => void, fallback: string): boolean {
+  try {
+    save();
+    return true;
+  } catch (err) {
+    serverError(res, err instanceof Error ? err.message : fallback);
+    return false;
+  }
+}
+
+const router = Router();
+
+router.get(API_ROUTES.config.base, (_req: Request, res: Response<ConfigResponse>) => {
+  res.json(buildFullResponse());
+});
+
+// Atomic save for both settings and MCP. Validates both payloads first
+// (no writes happen until every input is known-good), then writes
+// settings and captures the previous state so a subsequent saveMcpConfig
+// failure can roll back. This is the endpoint the Settings modal should
+// use; the per-section PUTs below remain for targeted updates.
+interface PutConfigBody {
+  settings: AppSettings;
+  mcp: { servers: McpServerEntry[] };
+}
+
+function isPutConfigBody(value: unknown): value is PutConfigBody {
+  if (!isRecord(value)) return false;
+  return isAppSettings(value.settings) && isMcpPutBody(value.mcp);
+}
+
+router.put(API_ROUTES.config.base, (req: Request<unknown, unknown, PutConfigBody>, res: ConfigRes) => {
+  const body = req.body;
+  if (!isPutConfigBody(body)) {
+    badRequest(res, "Invalid config payload");
+    return;
+  }
+  const mcpCfg = parseMcpPayloadOrFail(res, body.mcp.servers);
+  if (!mcpCfg) return;
+
+  // Snapshot previous settings so we can roll back if the second
+  // write fails — a cross-file atomic write isn't possible, but
+  // rollback keeps the pair consistent from the user's perspective.
+  const previousSettings = loadSettings();
+  if (!runSaveOrFail(res, () => saveSettings(body.settings), "saveSettings failed")) {
+    return;
+  }
+  if (!runSaveOrFail(res, () => saveMcpConfig(mcpCfg), "saveMcpConfig failed")) {
+    // Best-effort rollback; if it fails too, the original mcp error
+    // is already on the wire.
+    try {
+      saveSettings(previousSettings);
+    } catch {
+      /* swallow — original error already sent */
+    }
+    return;
+  }
+  res.json(buildFullResponse());
+});
+
+router.put(API_ROUTES.config.settings, (req: Request<unknown, unknown, AppSettings>, res: ConfigRes) => {
+  const body = req.body;
+  if (!isAppSettings(body)) {
+    badRequest(res, "Invalid AppSettings payload");
+    return;
+  }
+  if (!runSaveOrFail(res, () => saveSettings(body), "saveSettings failed")) {
+    return;
+  }
+  res.json(buildFullResponse());
+});
+
+router.put(API_ROUTES.config.mcp, (req: Request<unknown, unknown, { servers: McpServerEntry[] }>, res: ConfigRes) => {
+  const body = req.body;
+  if (!isMcpPutBody(body)) {
+    badRequest(res, "Invalid mcp payload envelope");
+    return;
+  }
+  // fromMcpEntries rejects malformed client input (400). saveMcpConfig
+  // can fail for server-side reasons like disk/permission errors (500).
+  const cfg = parseMcpPayloadOrFail(res, body.servers);
+  if (!cfg) return;
+  if (!runSaveOrFail(res, () => saveMcpConfig(cfg), "saveMcpConfig failed")) {
+    return;
+  }
+  res.json(buildFullResponse());
+});
+
+// ── Workspace custom directories (#239) ──────────────────────────
+
+router.get(API_ROUTES.config.workspaceDirs, (_req: Request, res: Response<{ dirs: CustomDirEntry[] }>) => {
+  res.json({ dirs: loadCustomDirs() });
+});
+
+router.put(
+  API_ROUTES.config.workspaceDirs,
+  (req: Request<unknown, unknown, { dirs: unknown }>, res: Response<{ dirs: CustomDirEntry[] } | ConfigErrorResponse>) => {
+    const body = req.body;
+    if (!isRecord(body) || !("dirs" in body)) {
+      badRequest(res, "expected { dirs: [...] }");
+      return;
+    }
+    const result = validateCustomDirs(body.dirs);
+    if ("error" in result) {
+      badRequest(res, result.error);
+      return;
+    }
+    try {
+      saveCustomDirs(result.entries);
+      ensureCustomDirs(result.entries);
+      res.json({ dirs: result.entries });
+    } catch (err) {
+      serverError(res, err instanceof Error ? err.message : "save failed");
+    }
+  },
+);
+
+// ── Reference directories (#455) ────────────────────────────────
+
+router.get(API_ROUTES.config.referenceDirs, (_req: Request, res: Response<{ dirs: ReferenceDirEntry[] }>) => {
+  res.json({ dirs: loadReferenceDirs() });
+});
+
+router.put(
+  API_ROUTES.config.referenceDirs,
+  (req: Request<unknown, unknown, { dirs: unknown }>, res: Response<{ dirs: ReferenceDirEntry[] } | ConfigErrorResponse>) => {
+    const body = req.body;
+    if (!isRecord(body) || !("dirs" in body)) {
+      badRequest(res, "expected { dirs: [...] }");
+      return;
+    }
+    const result = validateReferenceDirs(body.dirs);
+    if ("error" in result) {
+      badRequest(res, result.error);
+      return;
+    }
+    try {
+      saveReferenceDirs(result.entries);
+      res.json({ dirs: result.entries });
+    } catch (err) {
+      serverError(res, err instanceof Error ? err.message : "save failed");
+    }
+  },
+);
+
+// ── Scheduler overrides (#493) ──────────────────────────────────
+
+import { loadSchedulerOverrides, saveSchedulerOverrides, UTC_HH_MM_RE, type ScheduleOverrides } from "../../utils/files/scheduler-overrides-io.js";
+import { applyScheduleOverride } from "../../events/scheduler-adapter.js";
+import { SCHEDULE_TYPES } from "@receptron/task-scheduler";
+
+router.get(API_ROUTES.config.schedulerOverrides, (_req: Request, res: Response<{ overrides: ScheduleOverrides }>) => {
+  res.json({ overrides: loadSchedulerOverrides() });
+});
+
+router.put(
+  API_ROUTES.config.schedulerOverrides,
+  async (req: Request<unknown, unknown, { overrides: unknown }>, res: Response<{ overrides: ScheduleOverrides } | ConfigErrorResponse>) => {
+    const body = req.body;
+    if (!isRecord(body) || !("overrides" in body)) {
+      badRequest(res, "expected { overrides: { ... } }");
+      return;
+    }
+    const raw = body.overrides;
+    if (!isRecord(raw)) {
+      badRequest(res, "overrides must be an object");
+      return;
+    }
+    const overrides = raw as ScheduleOverrides;
+    try {
+      saveSchedulerOverrides(overrides);
+
+      // Apply to running task-manager immediately
+      for (const [taskId, ovr] of Object.entries(overrides)) {
+        if (typeof ovr.intervalMs === "number" && ovr.intervalMs > 0) {
+          await applyScheduleOverride(taskId, {
+            type: SCHEDULE_TYPES.interval,
+            intervalMs: ovr.intervalMs,
+          });
+        } else if (typeof ovr.time === "string" && UTC_HH_MM_RE.test(ovr.time)) {
+          await applyScheduleOverride(taskId, {
+            type: SCHEDULE_TYPES.daily,
+            time: ovr.time,
+          });
+        }
+      }
+
+      res.json({ overrides: loadSchedulerOverrides() });
+    } catch (err) {
+      serverError(res, err instanceof Error ? err.message : "save failed");
+    }
+  },
+);
+
+export default router;

package/server/api/routes/dispatchResponse.ts

@@ -0,0 +1,79 @@
+// Shared HTTP response plumbing for dispatcher-style POST routes
+// (currently todos and scheduler). Both routes follow the same
+// pattern: load items, run a pure dispatch function that returns a
+// discriminated `{ kind: "error" | "success" }` result, persist on
+// success when applicable, and translate to JSON. This module owns
+// the translation step so each route handler stays a few lines.
+
+import type { Response } from "express";
+import { errorMessage } from "../../utils/errors.js";
+import { sendError, serverError } from "../../utils/httpError.js";
+
+export type DispatchResult<T> =
+  | { kind: "error"; status: number; error: string }
+  | {
+      kind: "success";
+      items: T[];
+      message: string;
+      jsonData: Record<string, unknown>;
+    };
+
+export interface DispatchSuccessResponse<T> {
+  data: { items: T[] };
+  message: string;
+  jsonData: Record<string, unknown>;
+  instructions: string;
+  updating: boolean;
+}
+
+export interface DispatchErrorResponse {
+  error: string;
+}
+
+export interface RespondOptions<T> {
+  // Whether to call the persist callback before responding. Different
+  // routes have different read-only action rules (e.g. todos has a
+  // READ_ONLY_ACTIONS set, scheduler exempts only "show"), so the
+  // caller decides per-request.
+  shouldPersist: boolean;
+  // Per-route instructions string baked into the response.
+  instructions: string;
+  // Persistence callback. Called with the post-dispatch items only
+  // when shouldPersist is true.
+  persist: (items: T[]) => void;
+}
+
+// Translate a DispatchResult into the JSON response shape used by
+// dispatcher-style routes. Side-effects: calls `options.persist` on
+// success when `options.shouldPersist` is true; writes the response.
+//
+// Persistence failures are caught and translated into a structured
+// 500 JSON error so the route's response contract stays consistent —
+// otherwise an fs.writeFileSync throw would bubble out and trigger
+// Express's default HTML error page instead of the JSON shape that
+// clients expect.
+export function respondWithDispatchResult<T>(
+  res: Response<DispatchSuccessResponse<T> | DispatchErrorResponse>,
+  result: DispatchResult<T>,
+  options: RespondOptions<T>,
+): void {
+  if (result.kind === "error") {
+    sendError(res, result.status, result.error);
+    return;
+  }
+  if (options.shouldPersist) {
+    try {
+      options.persist(result.items);
+    } catch (err) {
+      serverError(res, `Failed to persist changes: ${errorMessage(err)}`);
+      return;
+    }
+  }
+  res.json({
+    data: { items: result.items },
+    message: result.message,
+    jsonData: result.jsonData,
+    instructions: options.instructions,
+    updating: true,
+  });
+}