@femtomc/mu-server 26.2.72 → 26.2.73

package/dist/server_routing.js

@@ -1,6 +1,7 @@
 import { extname, join, resolve } from "node:path";
 import { activityRoutes } from "./api/activities.js";
 import { configRoutes } from "./api/config.js";
+import { contextRoutes } from "./api/context.js";
 import { controlPlaneRoutes } from "./api/control_plane.js";
 import { cronRoutes } from "./api/cron.js";
 import { eventRoutes } from "./api/events.js";
@@ -9,6 +10,8 @@ import { heartbeatRoutes } from "./api/heartbeats.js";
 import { identityRoutes } from "./api/identities.js";
 import { issueRoutes } from "./api/issues.js";
 import { runRoutes } from "./api/runs.js";
+import { cronScheduleInputFromBody, hasCronScheduleInput, parseCronTarget } from "./cron_request.js";
+import { normalizeWakeMode } from "./server_types.js";
 const DEFAULT_MIME_TYPES = {
     ".html": "text/html; charset=utf-8",
     ".js": "text/javascript; charset=utf-8",
@@ -22,6 +25,109 @@ const DEFAULT_MIME_TYPES = {
     ".woff2": "font/woff2",
 };
 const DEFAULT_PUBLIC_DIR = join(new URL(".", import.meta.url).pathname, "..", "public");
+function readTrimmedString(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function readIntOrNull(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value)) {
+        return null;
+    }
+    return Math.trunc(value);
+}
+function readFiniteNumberOrNull(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return null;
+    }
+    return value;
+}
+function parseOptionalBoolean(value) {
+    if (value == null) {
+        return { ok: true, value: null };
+    }
+    if (typeof value === "boolean") {
+        return { ok: true, value };
+    }
+    return { ok: false, value: null };
+}
+function readCommaList(value) {
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => (typeof item === "string" ? item.trim() : ""))
+            .filter((item) => item.length > 0);
+    }
+    if (typeof value === "string") {
+        return value
+            .split(",")
+            .map((item) => item.trim())
+            .filter((item) => item.length > 0);
+    }
+    return [];
+}
+function parseHeartbeatTarget(body) {
+    const targetKind = readTrimmedString(body.target_kind).toLowerCase();
+    if (targetKind === "run") {
+        const jobId = readTrimmedString(body.run_job_id);
+        const rootIssueId = readTrimmedString(body.run_root_issue_id);
+        if (!jobId && !rootIssueId) {
+            return {
+                target: null,
+                error: "run target requires run_job_id or run_root_issue_id",
+            };
+        }
+        return {
+            target: {
+                kind: "run",
+                job_id: jobId || null,
+                root_issue_id: rootIssueId || null,
+            },
+            error: null,
+        };
+    }
+    if (targetKind === "activity") {
+        const activityId = readTrimmedString(body.activity_id);
+        if (!activityId) {
+            return {
+                target: null,
+                error: "activity target requires activity_id",
+            };
+        }
+        return {
+            target: {
+                kind: "activity",
+                activity_id: activityId,
+            },
+            error: null,
+        };
+    }
+    return {
+        target: null,
+        error: "target_kind must be run or activity",
+    };
+}
+function commandProgramFailureStatus(reason) {
+    if (reason === "not_found") {
+        return 404;
+    }
+    if (reason === "missing_target" || reason === "invalid_target" || reason === "invalid_schedule") {
+        return 400;
+    }
+    if (reason === "not_running" || reason === "failed") {
+        return 409;
+    }
+    return 400;
+}
+function commandCompletedResponse(headers, targetType, result) {
+    return Response.json({
+        ok: true,
+        result: {
+            kind: "completed",
+            command: {
+                target_type: targetType,
+                result,
+            },
+        },
+    }, { headers });
+}
 export function createServerRequestHandler(deps) {
     const publicDir = deps.publicDir ?? DEFAULT_PUBLIC_DIR;
     const mimeTypes = deps.mimeTypes ?? DEFAULT_MIME_TYPES;
@@ -84,10 +190,10 @@ export function createServerRequestHandler(deps) {
             if (!kind) {
                 return Response.json({ error: "kind is required" }, { status: 400, headers });
             }
-            let commandText;
+            let commandText = null;
             switch (kind) {
                 case "run_start": {
-                    const prompt = typeof body.prompt === "string" ? body.prompt.trim() : "";
+                    const prompt = readTrimmedString(body.prompt);
                     if (!prompt) {
                         return Response.json({ error: "prompt is required for run_start" }, { status: 400, headers });
                     }
@@ -98,7 +204,7 @@ export function createServerRequestHandler(deps) {
                     break;
                 }
                 case "run_resume": {
-                    const rootId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : "";
+                    const rootId = readTrimmedString(body.root_issue_id);
                     const maxSteps = typeof body.max_steps === "number" && Number.isFinite(body.max_steps)
                         ? ` ${Math.max(1, Math.trunc(body.max_steps))}`
                         : "";
@@ -106,7 +212,7 @@ export function createServerRequestHandler(deps) {
                     break;
                 }
                 case "run_interrupt": {
-                    const rootId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : "";
+                    const rootId = readTrimmedString(body.root_issue_id);
                     commandText = `mu! run interrupt${rootId ? ` ${rootId}` : ""}`;
                     break;
                 }
@@ -116,40 +222,434 @@ export function createServerRequestHandler(deps) {
                 case "update":
                     commandText = "/mu update";
                     break;
-                case "status":
-                    commandText = "/mu status";
-                    break;
-                case "issue_list":
-                    commandText = "/mu issue list";
-                    break;
-                case "issue_get": {
-                    const issueId = typeof body.issue_id === "string" ? body.issue_id.trim() : "";
-                    commandText = `/mu issue get${issueId ? ` ${issueId}` : ""}`;
-                    break;
+                case "issue_create": {
+                    const title = readTrimmedString(body.title);
+                    if (!title) {
+                        return Response.json({ error: "title is required for issue_create" }, { status: 400, headers });
+                    }
+                    const issueBody = typeof body.body === "string" ? body.body : undefined;
+                    const tags = readCommaList(body.tags);
+                    const priority = readIntOrNull(body.priority);
+                    if (body.priority != null && priority == null) {
+                        return Response.json({ error: "priority must be an integer" }, { status: 400, headers });
+                    }
+                    const created = await deps.context.issueStore.create(title, {
+                        body: issueBody,
+                        tags: tags.length > 0 ? tags : undefined,
+                        priority: priority ?? undefined,
+                    });
+                    const parentId = readTrimmedString(body.parent_id);
+                    if (parentId) {
+                        await deps.context.issueStore.add_dep(created.id, "parent", parentId);
+                    }
+                    const issue = parentId ? ((await deps.context.issueStore.get(created.id)) ?? created) : created;
+                    return commandCompletedResponse(headers, "issue create", { issue });
                 }
-                case "forum_read": {
-                    const topic = typeof body.topic === "string" ? body.topic.trim() : "";
-                    const limit = typeof body.limit === "number" && Number.isFinite(body.limit)
-                        ? ` ${Math.max(1, Math.trunc(body.limit))}`
-                        : "";
-                    commandText = `/mu forum read${topic ? ` ${topic}` : ""}${limit}`;
-                    break;
+                case "issue_update": {
+                    const id = readTrimmedString(body.id);
+                    if (!id) {
+                        return Response.json({ error: "id is required for issue_update" }, { status: 400, headers });
+                    }
+                    const current = await deps.context.issueStore.get(id);
+                    if (!current) {
+                        return Response.json({ error: "issue not found" }, { status: 404, headers });
+                    }
+                    const patch = {};
+                    if (typeof body.title === "string")
+                        patch.title = body.title;
+                    if (typeof body.body === "string")
+                        patch.body = body.body;
+                    if (typeof body.status === "string")
+                        patch.status = body.status;
+                    if (typeof body.outcome === "string")
+                        patch.outcome = body.outcome;
+                    if (body.priority != null) {
+                        const priority = readIntOrNull(body.priority);
+                        if (priority == null) {
+                            return Response.json({ error: "priority must be an integer" }, { status: 400, headers });
+                        }
+                        patch.priority = priority;
+                    }
+                    if (body.tags != null) {
+                        patch.tags = readCommaList(body.tags);
+                    }
+                    const addTags = readCommaList(body.add_tags);
+                    const removeTags = readCommaList(body.remove_tags);
+                    if (addTags.length > 0 || removeTags.length > 0) {
+                        const baseTags = Array.isArray(patch.tags)
+                            ? (patch.tags ?? [])
+                            : Array.isArray(current.tags)
+                                ? [...current.tags]
+                                : [];
+                        const next = new Set(baseTags);
+                        for (const tag of addTags)
+                            next.add(tag);
+                        for (const tag of removeTags)
+                            next.delete(tag);
+                        patch.tags = [...next];
+                    }
+                    if (Object.keys(patch).length === 0) {
+                        return Response.json({ error: "issue_update requires at least one patch field" }, { status: 400, headers });
+                    }
+                    const issue = await deps.context.issueStore.update(id, patch);
+                    return commandCompletedResponse(headers, "issue update", { issue });
                 }
-                case "run_list":
-                    commandText = "/mu run list";
-                    break;
-                case "run_status": {
-                    const rootId = typeof body.root_issue_id === "string" ? body.root_issue_id.trim() : "";
-                    commandText = `/mu run status${rootId ? ` ${rootId}` : ""}`;
-                    break;
+                case "issue_claim": {
+                    const id = readTrimmedString(body.id);
+                    if (!id) {
+                        return Response.json({ error: "id is required for issue_claim" }, { status: 400, headers });
+                    }
+                    const claimed = await deps.context.issueStore.claim(id);
+                    if (!claimed) {
+                        return Response.json({ error: "failed to claim issue" }, { status: 409, headers });
+                    }
+                    const issue = await deps.context.issueStore.get(id);
+                    if (!issue) {
+                        return Response.json({ error: "issue not found" }, { status: 404, headers });
+                    }
+                    return commandCompletedResponse(headers, "issue claim", { issue });
+                }
+                case "issue_open": {
+                    const id = readTrimmedString(body.id);
+                    if (!id) {
+                        return Response.json({ error: "id is required for issue_open" }, { status: 400, headers });
+                    }
+                    const issue = await deps.context.issueStore.update(id, { status: "open", outcome: null });
+                    return commandCompletedResponse(headers, "issue open", { issue });
+                }
+                case "issue_close": {
+                    const id = readTrimmedString(body.id);
+                    if (!id) {
+                        return Response.json({ error: "id is required for issue_close" }, { status: 400, headers });
+                    }
+                    const outcome = readTrimmedString(body.outcome) || "success";
+                    const issue = await deps.context.issueStore.close(id, outcome);
+                    return commandCompletedResponse(headers, "issue close", { issue });
+                }
+                case "issue_dep": {
+                    const srcId = readTrimmedString(body.src_id);
+                    const dstId = readTrimmedString(body.dst_id);
+                    const depType = readTrimmedString(body.dep_type) || "blocks";
+                    if (!srcId || !dstId) {
+                        return Response.json({ error: "src_id and dst_id are required for issue_dep" }, { status: 400, headers });
+                    }
+                    if (depType !== "blocks" && depType !== "parent") {
+                        return Response.json({ error: "dep_type must be blocks or parent" }, { status: 400, headers });
+                    }
+                    await deps.context.issueStore.add_dep(srcId, depType, dstId);
+                    return commandCompletedResponse(headers, "issue dep", {
+                        src_id: srcId,
+                        dst_id: dstId,
+                        dep_type: depType,
+                    });
+                }
+                case "issue_undep": {
+                    const srcId = readTrimmedString(body.src_id);
+                    const dstId = readTrimmedString(body.dst_id);
+                    const depType = readTrimmedString(body.dep_type) || "blocks";
+                    if (!srcId || !dstId) {
+                        return Response.json({ error: "src_id and dst_id are required for issue_undep" }, { status: 400, headers });
+                    }
+                    if (depType !== "blocks" && depType !== "parent") {
+                        return Response.json({ error: "dep_type must be blocks or parent" }, { status: 400, headers });
+                    }
+                    const ok = await deps.context.issueStore.remove_dep(srcId, depType, dstId);
+                    return commandCompletedResponse(headers, "issue undep", {
+                        src_id: srcId,
+                        dst_id: dstId,
+                        dep_type: depType,
+                        ok,
+                    });
+                }
+                case "forum_post": {
+                    const topic = readTrimmedString(body.topic);
+                    const messageBody = readTrimmedString(body.body);
+                    if (!topic) {
+                        return Response.json({ error: "topic is required for forum_post" }, { status: 400, headers });
+                    }
+                    if (!messageBody) {
+                        return Response.json({ error: "body is required for forum_post" }, { status: 400, headers });
+                    }
+                    const author = readTrimmedString(body.author) || "operator";
+                    const message = await deps.context.forumStore.post(topic, messageBody, author);
+                    return commandCompletedResponse(headers, "forum post", { message });
+                }
+                case "heartbeat_create": {
+                    const title = readTrimmedString(body.title);
+                    if (!title) {
+                        return Response.json({ error: "title is required for heartbeat_create" }, { status: 400, headers });
+                    }
+                    const parsedTarget = parseHeartbeatTarget(body);
+                    if (!parsedTarget.target) {
+                        return Response.json({ error: parsedTarget.error ?? "invalid target" }, { status: 400, headers });
+                    }
+                    const everyMsRaw = readFiniteNumberOrNull(body.every_ms);
+                    if (body.every_ms != null && everyMsRaw == null) {
+                        return Response.json({ error: "every_ms must be a finite number" }, { status: 400, headers });
+                    }
+                    if (body.reason != null && typeof body.reason !== "string") {
+                        return Response.json({ error: "reason must be a string" }, { status: 400, headers });
+                    }
+                    if (body.wake_mode != null && typeof body.wake_mode !== "string") {
+                        return Response.json({ error: "wake_mode must be a string" }, { status: 400, headers });
+                    }
+                    const enabled = parseOptionalBoolean(body.enabled);
+                    if (!enabled.ok) {
+                        return Response.json({ error: "enabled must be boolean" }, { status: 400, headers });
+                    }
+                    if (body.metadata != null &&
+                        (typeof body.metadata !== "object" || Array.isArray(body.metadata))) {
+                        return Response.json({ error: "metadata must be an object" }, { status: 400, headers });
+                    }
+                    try {
+                        const program = await deps.heartbeatPrograms.create({
+                            title,
+                            target: parsedTarget.target,
+                            everyMs: everyMsRaw == null ? undefined : Math.max(0, Math.trunc(everyMsRaw)),
+                            reason: typeof body.reason === "string" ? body.reason : undefined,
+                            wakeMode: body.wake_mode == null ? undefined : normalizeWakeMode(body.wake_mode),
+                            enabled: enabled.value ?? undefined,
+                            metadata: body.metadata,
+                        });
+                        return commandCompletedResponse(headers, "heartbeat create", { program });
+                    }
+                    catch (err) {
+                        return Response.json({ error: deps.describeError(err) }, { status: 400, headers });
+                    }
+                }
+                case "heartbeat_update": {
+                    const programId = readTrimmedString(body.program_id);
+                    if (!programId) {
+                        return Response.json({ error: "program_id is required for heartbeat_update" }, { status: 400, headers });
+                    }
+                    let target;
+                    if (body.target_kind != null) {
+                        const parsedTarget = parseHeartbeatTarget(body);
+                        if (!parsedTarget.target) {
+                            return Response.json({ error: parsedTarget.error ?? "invalid target" }, { status: 400, headers });
+                        }
+                        target = parsedTarget.target;
+                    }
+                    const everyMsRaw = readFiniteNumberOrNull(body.every_ms);
+                    if (body.every_ms != null && everyMsRaw == null) {
+                        return Response.json({ error: "every_ms must be a finite number" }, { status: 400, headers });
+                    }
+                    if (body.reason != null && typeof body.reason !== "string") {
+                        return Response.json({ error: "reason must be a string" }, { status: 400, headers });
+                    }
+                    if (body.wake_mode != null && typeof body.wake_mode !== "string") {
+                        return Response.json({ error: "wake_mode must be a string" }, { status: 400, headers });
+                    }
+                    const enabled = parseOptionalBoolean(body.enabled);
+                    if (!enabled.ok) {
+                        return Response.json({ error: "enabled must be boolean" }, { status: 400, headers });
+                    }
+                    if (body.metadata != null &&
+                        (typeof body.metadata !== "object" || Array.isArray(body.metadata))) {
+                        return Response.json({ error: "metadata must be an object" }, { status: 400, headers });
+                    }
+                    try {
+                        const result = await deps.heartbeatPrograms.update({
+                            programId,
+                            title: typeof body.title === "string" ? body.title : undefined,
+                            target,
+                            everyMs: everyMsRaw == null ? undefined : Math.max(0, Math.trunc(everyMsRaw)),
+                            reason: typeof body.reason === "string" ? body.reason : undefined,
+                            wakeMode: body.wake_mode == null ? undefined : normalizeWakeMode(body.wake_mode),
+                            enabled: enabled.value ?? undefined,
+                            metadata: body.metadata,
+                        });
+                        if (!result.ok) {
+                            return Response.json({ error: `heartbeat update failed: ${result.reason ?? "unknown"}` }, { status: commandProgramFailureStatus(result.reason), headers });
+                        }
+                        return commandCompletedResponse(headers, "heartbeat update", { program: result.program });
+                    }
+                    catch (err) {
+                        return Response.json({ error: deps.describeError(err) }, { status: 400, headers });
+                    }
+                }
+                case "heartbeat_delete": {
+                    const programId = readTrimmedString(body.program_id);
+                    if (!programId) {
+                        return Response.json({ error: "program_id is required for heartbeat_delete" }, { status: 400, headers });
+                    }
+                    const result = await deps.heartbeatPrograms.remove(programId);
+                    if (!result.ok) {
+                        return Response.json({ error: `heartbeat delete failed: ${result.reason ?? "unknown"}` }, { status: commandProgramFailureStatus(result.reason), headers });
+                    }
+                    return commandCompletedResponse(headers, "heartbeat delete", { program: result.program });
+                }
+                case "heartbeat_trigger": {
+                    const programId = readTrimmedString(body.program_id);
+                    if (!programId) {
+                        return Response.json({ error: "program_id is required for heartbeat_trigger" }, { status: 400, headers });
+                    }
+                    if (body.reason != null && typeof body.reason !== "string") {
+                        return Response.json({ error: "reason must be a string" }, { status: 400, headers });
+                    }
+                    const result = await deps.heartbeatPrograms.trigger({
+                        programId,
+                        reason: typeof body.reason === "string" ? body.reason : null,
+                    });
+                    if (!result.ok) {
+                        return Response.json({ error: `heartbeat trigger failed: ${result.reason ?? "unknown"}` }, { status: commandProgramFailureStatus(result.reason), headers });
+                    }
+                    return commandCompletedResponse(headers, "heartbeat trigger", { program: result.program });
+                }
+                case "heartbeat_enable":
+                case "heartbeat_disable": {
+                    const programId = readTrimmedString(body.program_id);
+                    if (!programId) {
+                        return Response.json({ error: `program_id is required for ${kind}` }, { status: 400, headers });
+                    }
+                    const result = await deps.heartbeatPrograms.update({
+                        programId,
+                        enabled: kind === "heartbeat_enable",
+                    });
+                    if (!result.ok) {
+                        return Response.json({ error: `${kind} failed: ${result.reason ?? "unknown"}` }, { status: commandProgramFailureStatus(result.reason), headers });
+                    }
+                    return commandCompletedResponse(headers, kind.replaceAll("_", " "), { program: result.program });
+                }
+                case "cron_create": {
+                    const title = readTrimmedString(body.title);
+                    if (!title) {
+                        return Response.json({ error: "title is required for cron_create" }, { status: 400, headers });
+                    }
+                    const parsedTarget = parseCronTarget(body);
+                    if (!parsedTarget.target) {
+                        return Response.json({ error: parsedTarget.error ?? "invalid target" }, { status: 400, headers });
+                    }
+                    if (!hasCronScheduleInput(body)) {
+                        return Response.json({ error: "schedule is required for cron_create" }, { status: 400, headers });
+                    }
+                    if (body.reason != null && typeof body.reason !== "string") {
+                        return Response.json({ error: "reason must be a string" }, { status: 400, headers });
+                    }
+                    if (body.wake_mode != null && typeof body.wake_mode !== "string") {
+                        return Response.json({ error: "wake_mode must be a string" }, { status: 400, headers });
+                    }
+                    const enabled = parseOptionalBoolean(body.enabled);
+                    if (!enabled.ok) {
+                        return Response.json({ error: "enabled must be boolean" }, { status: 400, headers });
+                    }
+                    if (body.metadata != null &&
+                        (typeof body.metadata !== "object" || Array.isArray(body.metadata))) {
+                        return Response.json({ error: "metadata must be an object" }, { status: 400, headers });
+                    }
+                    try {
+                        const program = await deps.cronPrograms.create({
+                            title,
+                            target: parsedTarget.target,
+                            schedule: cronScheduleInputFromBody(body),
+                            reason: typeof body.reason === "string" ? body.reason : undefined,
+                            wakeMode: body.wake_mode == null ? undefined : normalizeWakeMode(body.wake_mode),
+                            enabled: enabled.value ?? undefined,
+                            metadata: body.metadata,
+                        });
+                        return commandCompletedResponse(headers, "cron create", { program });
+                    }
+                    catch (err) {
+                        return Response.json({ error: deps.describeError(err) }, { status: 400, headers });
+                    }
+                }
+                case "cron_update": {
+                    const programId = readTrimmedString(body.program_id);
+                    if (!programId) {
+                        return Response.json({ error: "program_id is required for cron_update" }, { status: 400, headers });
+                    }
+                    let target;
+                    if (body.target_kind != null) {
+                        const parsedTarget = parseCronTarget(body);
+                        if (!parsedTarget.target) {
+                            return Response.json({ error: parsedTarget.error ?? "invalid target" }, { status: 400, headers });
+                        }
+                        target = parsedTarget.target;
+                    }
+                    if (body.reason != null && typeof body.reason !== "string") {
+                        return Response.json({ error: "reason must be a string" }, { status: 400, headers });
+                    }
+                    if (body.wake_mode != null && typeof body.wake_mode !== "string") {
+                        return Response.json({ error: "wake_mode must be a string" }, { status: 400, headers });
+                    }
+                    const enabled = parseOptionalBoolean(body.enabled);
+                    if (!enabled.ok) {
+                        return Response.json({ error: "enabled must be boolean" }, { status: 400, headers });
+                    }
+                    if (body.metadata != null &&
+                        (typeof body.metadata !== "object" || Array.isArray(body.metadata))) {
+                        return Response.json({ error: "metadata must be an object" }, { status: 400, headers });
+                    }
+                    try {
+                        const result = await deps.cronPrograms.update({
+                            programId,
+                            title: typeof body.title === "string" ? body.title : undefined,
+                            reason: typeof body.reason === "string" ? body.reason : undefined,
+                            wakeMode: body.wake_mode == null ? undefined : normalizeWakeMode(body.wake_mode),
+                            enabled: enabled.value ?? undefined,
+                            target,
+                            schedule: hasCronScheduleInput(body) ? cronScheduleInputFromBody(body) : undefined,
+                            metadata: body.metadata,
+                        });
+                        if (!result.ok) {
+                            return Response.json({ error: `cron update failed: ${result.reason ?? "unknown"}` }, { status: commandProgramFailureStatus(result.reason), headers });
+                        }
+                        return commandCompletedResponse(headers, "cron update", { program: result.program });
+                    }
+                    catch (err) {
+                        return Response.json({ error: deps.describeError(err) }, { status: 400, headers });
+                    }
+                }
+                case "cron_delete": {
+                    const programId = readTrimmedString(body.program_id);
+                    if (!programId) {
+                        return Response.json({ error: "program_id is required for cron_delete" }, { status: 400, headers });
+                    }
+                    const result = await deps.cronPrograms.remove(programId);
+                    if (!result.ok) {
+                        return Response.json({ error: `cron delete failed: ${result.reason ?? "unknown"}` }, { status: commandProgramFailureStatus(result.reason), headers });
+                    }
+                    return commandCompletedResponse(headers, "cron delete", { program: result.program });
+                }
+                case "cron_trigger": {
+                    const programId = readTrimmedString(body.program_id);
+                    if (!programId) {
+                        return Response.json({ error: "program_id is required for cron_trigger" }, { status: 400, headers });
+                    }
+                    if (body.reason != null && typeof body.reason !== "string") {
+                        return Response.json({ error: "reason must be a string" }, { status: 400, headers });
+                    }
+                    const result = await deps.cronPrograms.trigger({
+                        programId,
+                        reason: typeof body.reason === "string" ? body.reason : null,
+                    });
+                    if (!result.ok) {
+                        return Response.json({ error: `cron trigger failed: ${result.reason ?? "unknown"}` }, { status: commandProgramFailureStatus(result.reason), headers });
+                    }
+                    return commandCompletedResponse(headers, "cron trigger", { program: result.program });
+                }
+                case "cron_enable":
+                case "cron_disable": {
+                    const programId = readTrimmedString(body.program_id);
+                    if (!programId) {
+                        return Response.json({ error: `program_id is required for ${kind}` }, { status: 400, headers });
+                    }
+                    const result = await deps.cronPrograms.update({
+                        programId,
+                        enabled: kind === "cron_enable",
+                    });
+                    if (!result.ok) {
+                        return Response.json({ error: `${kind} failed: ${result.reason ?? "unknown"}` }, { status: commandProgramFailureStatus(result.reason), headers });
+                    }
+                    return commandCompletedResponse(headers, kind.replaceAll("_", " "), { program: result.program });
                 }
-                case "ready":
-                    commandText = "/mu ready";
-                    break;
                 default:
                     return Response.json({ error: `unknown command kind: ${kind}` }, { status: 400, headers });
             }
             try {
+                if (!commandText) {
+                    return Response.json({ error: `unknown command kind: ${kind}` }, { status: 400, headers });
+                }
                 if (!deps.controlPlaneProxy.submitTerminalCommand) {
                     return Response.json({ error: "control plane not available" }, { status: 503, headers });
                 }
@@ -199,6 +699,9 @@ export function createServerRequestHandler(deps) {
             });
             return response;
         }
+        if (path === "/api/context" || path.startsWith("/api/context/")) {
+            return contextRoutes(request, url, { context: deps.context, describeError: deps.describeError }, headers);
+        }
         if (path.startsWith("/webhooks/")) {
             const response = await deps.controlPlaneProxy.handleWebhook(path, request);
             if (response) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@femtomc/mu-server",
-  "version": "26.2.72",
+  "version": "26.2.73",
   "description": "HTTP API server for mu status, work items, messaging setup, and web UI.",
   "keywords": [
     "mu",
@@ -31,11 +31,10 @@
     "start": "bun run dist/cli.js"
   },
   "dependencies": {
-    "@femtomc/mu-agent": "26.2.72",
-    "@femtomc/mu-control-plane": "26.2.72",
-    "@femtomc/mu-core": "26.2.72",
-    "@femtomc/mu-forum": "26.2.72",
-    "@femtomc/mu-issue": "26.2.72",
-    "@femtomc/mu-orchestrator": "26.2.72"
+    "@femtomc/mu-agent": "26.2.73",
+    "@femtomc/mu-control-plane": "26.2.73",
+    "@femtomc/mu-core": "26.2.73",
+    "@femtomc/mu-forum": "26.2.73",
+    "@femtomc/mu-issue": "26.2.73"
   }
 }