mulmoclaude 0.1.0

package/server/api/routes/roles.ts

@@ -0,0 +1,125 @@
+import { Router, Request, Response } from "express";
+import { getSessionQuery } from "../../utils/request.js";
+import { loadCustomRoles } from "../../workspace/roles.js";
+import { BUILTIN_ROLES, type Role } from "../../../src/config/roles.js";
+import { pushSessionEvent } from "../../events/session-store/index.js";
+import { API_ROUTES } from "../../../src/config/apiRoutes.js";
+import { EVENT_TYPES } from "../../../src/types/events.js";
+import { roleExists, deleteRole, saveRole } from "../../utils/files/roles-io.js";
+
+const BUILTIN_IDS = new Set(BUILTIN_ROLES.map((r) => r.id));
+
+const router = Router();
+
+router.get(API_ROUTES.roles.list, (_req: Request, res: Response<Role[]>) => {
+  res.json(loadCustomRoles());
+});
+
+router.post(API_ROUTES.roles.manage, async (req: Request, res: Response<Record<string, unknown>>) => {
+  const session = getSessionQuery(req);
+  const result = await executeManageRoles(req.body, session);
+  res.json(result);
+});
+
+export default router;
+
+function notifyRolesUpdated(chatSessionId: string): void {
+  pushSessionEvent(chatSessionId, { type: EVENT_TYPES.rolesUpdated });
+}
+
+interface ManageRolesInput {
+  action: string;
+  role?: {
+    id: string;
+    name: string;
+    icon: string;
+    prompt: string;
+    availablePlugins: string[];
+    queries?: string[];
+  };
+  roleId?: string;
+  oldRoleId?: string;
+}
+
+function listRolesResult(): Record<string, unknown> {
+  const customRoles = loadCustomRoles();
+  return {
+    success: true,
+    message: `${customRoles.length} custom role${customRoles.length !== 1 ? "s" : ""}.`,
+    data: { customRoles },
+  };
+}
+
+function deleteRoleResult(roleId: string | undefined, sessionId: string): Record<string, unknown> {
+  if (!roleId) return { success: false, error: "roleId is required for delete action" };
+  if (BUILTIN_IDS.has(roleId)) {
+    return { success: false, error: "Cannot delete built-in roles." };
+  }
+  if (!roleExists(roleId)) {
+    return { success: false, error: `Role '${roleId}' not found.` };
+  }
+  deleteRole(roleId);
+  notifyRolesUpdated(sessionId);
+  return {
+    success: true,
+    message: `Role '${roleId}' deleted.`,
+    roles: loadCustomRoles(),
+  };
+}
+
+function validateSaveInput(input: ManageRolesInput): { role: NonNullable<ManageRolesInput["role"]>; isRename: boolean } | string {
+  const { action, role, oldRoleId } = input;
+  if (!role) return "role definition required for create/update";
+  if (!role.id) return "role.id is required";
+
+  // Rename is strictly an update-with-different-id. Gating on
+  // action === "update" means a malformed create payload that
+  // happens to include `oldRoleId` cannot silently delete an
+  // unrelated file via the rename cleanup below.
+  const isRename = Boolean(action === "update" && oldRoleId && oldRoleId !== role.id);
+  if (BUILTIN_IDS.has(role.id) && (action === "create" || isRename)) {
+    return `ID '${role.id}' is reserved for a built-in role.`;
+  }
+  if ((action === "create" || isRename) && roleExists(role.id)) {
+    return `A role with ID '${role.id}' already exists.`;
+  }
+  return { role, isRename };
+}
+
+function saveRoleResult(input: ManageRolesInput, sessionId: string): Record<string, unknown> {
+  const validated = validateSaveInput(input);
+  if (typeof validated === "string") {
+    return { success: false, error: validated };
+  }
+  const { role, isRename } = validated;
+  const { action, oldRoleId } = input;
+
+  // Strip switchRole before saving — it is injected at load time by server/roles.ts
+  const pluginsToSave = role.availablePlugins ?? [];
+  const roleToSave = {
+    ...role,
+    availablePlugins: pluginsToSave.filter((p) => p !== "switchRole"),
+  };
+
+  saveRole(role.id, roleToSave);
+  // On rename, remove the old file even if its id matches a built-in —
+  // a file at `config/roles/<builtin>.json` is a user-created override,
+  // not the built-in itself (which lives in BUILTIN_ROLES). Leaving it
+  // behind would shadow the built-in and couldn't be cleaned up via
+  // `delete`, which also rejects built-in ids.
+  if (isRename && oldRoleId && roleExists(oldRoleId)) {
+    deleteRole(oldRoleId);
+  }
+  notifyRolesUpdated(sessionId);
+  return {
+    success: true,
+    message: `Role '${role.name}' ${action}d successfully.`,
+    roles: loadCustomRoles(),
+  };
+}
+
+export async function executeManageRoles(input: ManageRolesInput, sessionId: string): Promise<Record<string, unknown>> {
+  if (input.action === "list") return listRolesResult();
+  if (input.action === "delete") return deleteRoleResult(input.roleId, sessionId);
+  return saveRoleResult(input, sessionId);
+}

package/server/api/routes/scheduler.ts

@@ -0,0 +1,153 @@
+import { Router, Request, Response } from "express";
+import { loadSchedulerItems, saveSchedulerItems } from "../../utils/files/scheduler-io.js";
+import { dispatchScheduler, type SchedulerActionInput } from "./schedulerHandlers.js";
+import { respondWithDispatchResult, type DispatchSuccessResponse, type DispatchErrorResponse } from "./dispatchResponse.js";
+import { API_ROUTES } from "../../../src/config/apiRoutes.js";
+import { SESSION_ORIGINS } from "../../../src/types/session.js";
+import { loadUserTasks, validateAndCreate, refreshUserTasks } from "../../workspace/skills/user-tasks.js";
+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/config/schedulerActions.js";
+
+const router = Router();
+
+export interface ScheduledItem {
+  id: string;
+  title: string;
+  createdAt: number;
+  props: Record<string, string | number | boolean | null>;
+}
+
+function loadItems(): ScheduledItem[] {
+  return loadSchedulerItems<ScheduledItem[]>([]);
+}
+
+function saveItems(items: ScheduledItem[]): void {
+  saveSchedulerItems(items);
+}
+
+router.get(API_ROUTES.scheduler.base, (_req: Request, res: Response<{ data: { items: ScheduledItem[] } }>) => {
+  res.json({ data: { items: loadItems() } });
+});
+
+interface SchedulerBody extends SchedulerActionInput {
+  action: string;
+  // Task-related fields
+  name?: string;
+  prompt?: string;
+  schedule?: unknown;
+  roleId?: string;
+}
+
+router.post(
+  API_ROUTES.scheduler.base,
+  async (req: Request<object, unknown, SchedulerBody>, res: Response<DispatchSuccessResponse<ScheduledItem> | DispatchErrorResponse | unknown>) => {
+    const { action, ...input } = req.body;
+
+    // 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,
+    });
+  },
+);
+
+async function handleTaskAction(action: string, input: Record<string, unknown>, res: Response): Promise<void> {
+  try {
+    if (action === SCHEDULER_ACTIONS.listTasks) {
+      const tasks = loadUserTasks();
+      res.json({
+        uuid: crypto.randomUUID(),
+        message: `${tasks.length} scheduled task(s) found.`,
+        data: { tasks },
+      });
+      return;
+    }
+
+    if (action === SCHEDULER_ACTIONS.createTask) {
+      const result = validateAndCreate(input);
+      if (result.kind === "error") {
+        res.status(400).json({ error: result.error });
+        return;
+      }
+      const tasks = loadUserTasks();
+      tasks.push(result.task);
+      await saveUserTasks(tasks);
+      await refreshUserTasks();
+      res.json({
+        uuid: crypto.randomUUID(),
+        message: `Task "${result.task.name}" created and scheduled.`,
+        data: { task: result.task },
+      });
+      return;
+    }
+
+    if (action === SCHEDULER_ACTIONS.deleteTask) {
+      const id = typeof input.id === "string" ? input.id : "";
+      const tasks = loadUserTasks();
+      const idx = tasks.findIndex((t) => t.id === id);
+      if (idx === -1) {
+        res.status(404).json({ error: `task not found: ${id}` });
+        return;
+      }
+      const name = tasks[idx].name;
+      tasks.splice(idx, 1);
+      await saveUserTasks(tasks);
+      await refreshUserTasks();
+      res.json({
+        uuid: crypto.randomUUID(),
+        message: `Task "${name}" deleted.`,
+        data: { deleted: id },
+      });
+      return;
+    }
+
+    if (action === SCHEDULER_ACTIONS.runTask) {
+      const id = typeof input.id === "string" ? input.id : "";
+      const tasks = loadUserTasks();
+      const task = tasks.find((t) => t.id === id);
+      if (!task) {
+        res.status(404).json({ error: `task not found: ${id}` });
+        return;
+      }
+      const chatSessionId = crypto.randomUUID();
+      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: crypto.randomUUID(),
+        message: `Task "${task.name}" triggered.`,
+        data: { triggered: id, chatSessionId },
+      });
+      return;
+    }
+
+    res.status(400).json({ error: `unknown task action: ${action}` });
+  } catch (err) {
+    log.error("scheduler", "task action failed", { error: String(err) });
+    res.status(500).json({ error: "Internal server error" });
+  }
+}
+
+export default router;

package/server/api/routes/schedulerHandlers.ts

@@ -0,0 +1,151 @@
+// Pure action handlers for the scheduler POST route. Each handler
+// takes the current items + the relevant body fields and returns
+// a discriminated result describing either an HTTP error or the
+// next state. The route handler in scheduler.ts dispatches to one
+// of these and translates the result into an HTTP response.
+//
+// Keeping the action logic pure (no I/O, no globals) makes it
+// straightforward to unit-test every case in isolation, and brings
+// the cognitive complexity of the route handler under the lint
+// threshold.
+
+import type { ScheduledItem } from "./scheduler.js";
+import { makeId } from "../../utils/id.js";
+
+export interface SchedulerActionInput {
+  title?: string;
+  id?: string;
+  props?: Record<string, string | number | boolean | null>;
+  items?: ScheduledItem[];
+}
+
+export type SchedulerActionResult =
+  | { kind: "error"; status: number; error: string }
+  | {
+      kind: "success";
+      items: ScheduledItem[];
+      message: string;
+      jsonData: Record<string, unknown>;
+    };
+
+export function sortItems(items: ScheduledItem[]): ScheduledItem[] {
+  return [...items].sort((a, b) => {
+    const aDate = typeof a.props.date === "string" ? a.props.date : null;
+    const bDate = typeof b.props.date === "string" ? b.props.date : null;
+    const aTime = typeof a.props.time === "string" ? a.props.time : "00:00";
+    const bTime = typeof b.props.time === "string" ? b.props.time : "00:00";
+    const aKey = aDate ? `0_${aDate}_${aTime}` : `1_${a.createdAt}`;
+    const bKey = bDate ? `0_${bDate}_${bTime}` : `1_${b.createdAt}`;
+    return aKey < bKey ? -1 : aKey > bKey ? 1 : 0;
+  });
+}
+
+export function handleShow(items: ScheduledItem[]): SchedulerActionResult {
+  return {
+    kind: "success",
+    items,
+    message: `Showing ${items.length} scheduled item(s)`,
+    jsonData: {},
+  };
+}
+
+export function handleAdd(items: ScheduledItem[], input: SchedulerActionInput): SchedulerActionResult {
+  if (!input.title) {
+    return { kind: "error", status: 400, error: "title required" };
+  }
+  const item: ScheduledItem = {
+    id: makeId("sched"),
+    title: input.title,
+    createdAt: Date.now(),
+    props: input.props ?? {},
+  };
+  const next = sortItems([...items, item]);
+  return {
+    kind: "success",
+    items: next,
+    message: `Added: "${input.title}"`,
+    jsonData: { added: item.id },
+  };
+}
+
+export function handleDelete(items: ScheduledItem[], input: SchedulerActionInput): SchedulerActionResult {
+  if (!input.id) {
+    return { kind: "error", status: 400, error: "id required" };
+  }
+  const next = items.filter((i) => i.id !== input.id);
+  const found = next.length < items.length;
+  return {
+    kind: "success",
+    items: next,
+    message: found ? `Deleted item ${input.id}` : `Item not found: ${input.id}`,
+    jsonData: { deleted: input.id },
+  };
+}
+
+function applyPropPatch(current: ScheduledItem["props"], patch: Record<string, string | number | boolean | null>): ScheduledItem["props"] {
+  const next: ScheduledItem["props"] = { ...current };
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === null) {
+      delete next[k];
+    } else {
+      next[k] = v;
+    }
+  }
+  return next;
+}
+
+export function handleUpdate(items: ScheduledItem[], input: SchedulerActionInput): SchedulerActionResult {
+  if (!input.id) {
+    return { kind: "error", status: 400, error: "id required" };
+  }
+  const target = items.find((i) => i.id === input.id);
+  if (!target) {
+    return {
+      kind: "success",
+      items,
+      message: `Item not found: ${input.id}`,
+      jsonData: {},
+    };
+  }
+  const updated: ScheduledItem = {
+    ...target,
+    title: input.title !== undefined ? input.title : target.title,
+    props: input.props !== undefined ? applyPropPatch(target.props, input.props) : target.props,
+  };
+  const next = sortItems(items.map((i) => (i.id === input.id ? updated : i)));
+  return {
+    kind: "success",
+    items: next,
+    message: `Updated: "${updated.title}"`,
+    jsonData: { updated: input.id },
+  };
+}
+
+export function handleReplace(_items: ScheduledItem[], input: SchedulerActionInput): SchedulerActionResult {
+  if (!Array.isArray(input.items)) {
+    return { kind: "error", status: 400, error: "items array required" };
+  }
+  const next = sortItems(input.items);
+  return {
+    kind: "success",
+    items: next,
+    message: `Replaced all items (${next.length} total)`,
+    jsonData: { count: next.length },
+  };
+}
+
+const HANDLERS: Record<string, (items: ScheduledItem[], input: SchedulerActionInput) => SchedulerActionResult> = {
+  show: handleShow,
+  add: handleAdd,
+  delete: handleDelete,
+  update: handleUpdate,
+  replace: handleReplace,
+};
+
+export function dispatchScheduler(action: string, items: ScheduledItem[], input: SchedulerActionInput): SchedulerActionResult {
+  const handler = HANDLERS[action];
+  if (!handler) {
+    return { kind: "error", status: 400, error: `Unknown action: ${action}` };
+  }
+  return handler(items, input);
+}

package/server/api/routes/schedulerTasks.ts

@@ -0,0 +1,163 @@
+// API routes for the unified scheduler (#357).
+//
+//   GET    /api/scheduler/tasks        — all registered tasks + state
+//   POST   /api/scheduler/tasks        — create user task
+//   PUT    /api/scheduler/tasks/:id    — update user task
+//   DELETE /api/scheduler/tasks/:id    — delete user task
+//   POST   /api/scheduler/tasks/:id/run — manual trigger
+//   GET    /api/scheduler/logs         — execution log (newest first)
+
+import { Router, type Request, type Response } from "express";
+import { getSchedulerTasks, getSchedulerLogs } from "../../events/scheduler-adapter.js";
+import type { TaskLogEntry } from "@receptron/task-scheduler";
+import { API_ROUTES } from "../../../src/config/apiRoutes.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 { errorMessage } from "../../utils/errors.js";
+import { log } from "../../system/logger/index.js";
+import { startChat } from "./agent.js";
+
+const router = Router();
+
+// ── List all tasks ──────────────────────────────────────────────
+
+router.get(API_ROUTES.scheduler.tasks, (_req: Request, res: Response) => {
+  // getSchedulerTasks() returns system-only tasks (registered via
+  // initScheduler at startup — journal, chat-index, sources, etc.).
+  // origin: "system" is correct, not an overwrite — these tasks
+  // have no origin field of their own.
+  const systemTasks = getSchedulerTasks();
+  const userTasks = loadUserTasks();
+  const all = [...systemTasks.map((t) => ({ ...t, origin: "system" as const })), ...userTasks.map((t) => ({ ...t, origin: "user" as const }))];
+  res.json({ tasks: all });
+});
+
+// ── Create user task ────────────────────────────────────────────
+
+router.post(API_ROUTES.scheduler.tasks, async (req: Request, res: Response) => {
+  const validated = validateAndCreate(req.body);
+  if (validated.kind === "error") {
+    badRequest(res, validated.error);
+    return;
+  }
+  try {
+    const task = await withUserTaskLock(async (tasks) => ({
+      tasks: [...tasks, validated.task],
+      result: validated.task,
+    }));
+    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 ────────────────────────────────────────────
+
+router.put(API_ROUTES.scheduler.task, async (req: Request<{ id: string }>, res: Response) => {
+  const { id } = req.params;
+  try {
+    const updated = await withUserTaskLock(async (tasks) => {
+      const result = applyUpdate(tasks, id, req.body);
+      if (result.kind === "error") {
+        throw new Error(result.error);
+      }
+      const task = result.tasks.find((t) => t.id === id);
+      return { tasks: result.tasks, result: task };
+    });
+    res.json({ task: updated });
+  } catch (err) {
+    const msg = errorMessage(err);
+    if (msg.startsWith("task not found") || msg.startsWith("request body")) {
+      notFound(res, msg);
+      return;
+    }
+    log.error("scheduler-tasks", "update failed", { error: msg });
+    serverError(res, "Failed to update task");
+  }
+});
+
+// ── Delete user task ────────────────────────────────────────────
+
+router.delete(API_ROUTES.scheduler.task, async (req: Request<{ id: string }>, res: Response) => {
+  const { id } = req.params;
+  try {
+    await withUserTaskLock(async (tasks) => {
+      const idx = tasks.findIndex((t) => t.id === id);
+      if (idx === -1) throw new Error(`task not found: ${id}`);
+      const next = tasks.filter((t) => t.id !== id);
+      return { tasks: next, result: undefined };
+    });
+    res.json({ deleted: id });
+  } catch (err) {
+    const msg = errorMessage(err);
+    if (msg.startsWith("task not found")) {
+      notFound(res, msg);
+      return;
+    }
+    log.error("scheduler-tasks", "delete failed", { error: msg });
+    serverError(res, "Failed to delete task");
+  }
+});
+
+// ── Manual trigger ──────────────────────────────────────────────
+
+router.post(API_ROUTES.scheduler.taskRun, async (req: Request<{ id: string }>, res: Response) => {
+  const { id } = req.params;
+  // Check user tasks first
+  const userTasks = loadUserTasks();
+  const userTask = userTasks.find((t) => t.id === id);
+  if (userTask) {
+    const chatSessionId = crypto.randomUUID();
+    log.info("scheduler-tasks", "manual run (user task)", {
+      name: userTask.name,
+      chatSessionId,
+    });
+    startChat({
+      message: userTask.prompt,
+      roleId: userTask.roleId,
+      chatSessionId,
+      origin: SESSION_ORIGINS.scheduler,
+    }).catch((err) => {
+      log.error("scheduler-tasks", "manual run failed", {
+        error: String(err),
+      });
+    });
+    res.json({ triggered: id, chatSessionId });
+    return;
+  }
+  // Not a user task — check system/skill tasks
+  const systemTasks = getSchedulerTasks();
+  const found = systemTasks.find((t) => t.id === id);
+  if (!found) {
+    notFound(res, `task not found: ${id}`);
+    return;
+  }
+  // System tasks don't have a prompt to startChat with — return 400
+  badRequest(res, "manual run is only supported for user tasks");
+});
+
+// ── Execution logs ──────────────────────────────────────────────
+
+interface LogQuery {
+  since?: string;
+  taskId?: string;
+  limit?: string;
+}
+
+router.get(API_ROUTES.scheduler.logs, async (req: Request<object, unknown, object, LogQuery>, res: Response<{ logs: TaskLogEntry[] }>) => {
+  const MAX_LIMIT = 500;
+  const rawLimit = typeof req.query.limit === "string" ? parseInt(req.query.limit, 10) : undefined;
+  const limit = Number.isFinite(rawLimit) && rawLimit! > 0 ? Math.min(rawLimit!, MAX_LIMIT) : undefined;
+  const logs = await getSchedulerLogs({
+    since: typeof req.query.since === "string" ? req.query.since : undefined,
+    taskId: typeof req.query.taskId === "string" ? req.query.taskId : undefined,
+    limit,
+  });
+  res.json({ logs });
+});
+
+export default router;