@femtomc/mu-server 26.2.73 → 26.2.75

package/dist/server_program_orchestration.js

@@ -1,25 +1,34 @@
 import { CronProgramRegistry } from "./cron_programs.js";
 import { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
-const AUTO_RUN_HEARTBEAT_REASON = "auto-run-heartbeat";
+function describeError(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    return String(err);
+}
 export function createServerProgramOrchestration(opts) {
-    const autoRunHeartbeatProgramByJobId = new Map();
     const heartbeatPrograms = new HeartbeatProgramRegistry({
         repoRoot: opts.repoRoot,
         heartbeatScheduler: opts.heartbeatScheduler,
-        runHeartbeat: async (runOpts) => {
-            const result = await opts.controlPlaneProxy.heartbeatRun?.({
-                jobId: runOpts.jobId ?? null,
-                rootIssueId: runOpts.rootIssueId ?? null,
-                reason: runOpts.reason ?? null,
-                wakeMode: runOpts.wakeMode,
-            });
-            return result ?? { ok: false, reason: "not_found" };
-        },
-        activityHeartbeat: async (activityOpts) => {
-            return opts.activitySupervisor.heartbeat({
-                activityId: activityOpts.activityId ?? null,
-                reason: activityOpts.reason ?? null,
+        dispatchWake: async (wakeOpts) => {
+            const wakeResult = await opts.emitOperatorWake({
+                dedupeKey: `heartbeat-program:${wakeOpts.programId}`,
+                message: `Heartbeat wake: ${wakeOpts.title}`,
+                payload: {
+                    wake_source: "heartbeat_program",
+                    source_ts_ms: wakeOpts.triggeredAtMs,
+                    program_id: wakeOpts.programId,
+                    reason: wakeOpts.reason,
+                    metadata: wakeOpts.metadata,
+                },
             });
+            if (wakeResult.status === "coalesced") {
+                return { status: "coalesced", reason: wakeResult.reason };
+            }
+            if (wakeResult.status === "failed") {
+                return { status: "failed", reason: wakeResult.reason };
+            }
+            return { status: "ok" };
         },
         onTickEvent: async (event) => {
             await opts.eventLog.emit("heartbeat_program.tick", {
@@ -32,44 +41,36 @@ export function createServerProgramOrchestration(opts) {
                     program: event.program,
                 },
             });
-            await opts.emitOperatorWake({
-                dedupeKey: `heartbeat-program:${event.program_id}`,
-                message: event.message,
-                payload: {
-                    wake_source: "heartbeat_program",
-                    source_ts_ms: event.ts_ms,
-                    program_id: event.program_id,
-                    status: event.status,
-                    reason: event.reason,
-                    wake_mode: event.program.wake_mode,
-                    target_kind: event.program.target.kind,
-                    target: event.program.target.kind === "run"
-                        ? {
-                            job_id: event.program.target.job_id,
-                            root_issue_id: event.program.target.root_issue_id,
-                        }
-                        : { activity_id: event.program.target.activity_id },
-                },
-            });
         },
     });
     const cronPrograms = new CronProgramRegistry({
         repoRoot: opts.repoRoot,
         heartbeatScheduler: opts.heartbeatScheduler,
-        runHeartbeat: async (runOpts) => {
-            const result = await opts.controlPlaneProxy.heartbeatRun?.({
-                jobId: runOpts.jobId ?? null,
-                rootIssueId: runOpts.rootIssueId ?? null,
-                reason: runOpts.reason ?? null,
-                wakeMode: runOpts.wakeMode,
-            });
-            return result ?? { ok: false, reason: "not_found" };
-        },
-        activityHeartbeat: async (activityOpts) => {
-            return opts.activitySupervisor.heartbeat({
-                activityId: activityOpts.activityId ?? null,
-                reason: activityOpts.reason ?? null,
-            });
+        dispatchWake: async (wakeOpts) => {
+            try {
+                const wakeResult = await opts.emitOperatorWake({
+                    dedupeKey: `cron-program:${wakeOpts.programId}`,
+                    message: `Cron wake: ${wakeOpts.title}`,
+                    payload: {
+                        wake_source: "cron_program",
+                        source_ts_ms: wakeOpts.triggeredAtMs,
+                        program_id: wakeOpts.programId,
+                        reason: wakeOpts.reason,
+                        schedule: wakeOpts.schedule,
+                        metadata: wakeOpts.metadata,
+                    },
+                });
+                if (wakeResult.status === "coalesced") {
+                    return { status: "coalesced", reason: wakeResult.reason };
+                }
+                if (wakeResult.status === "failed") {
+                    return { status: "failed", reason: wakeResult.reason };
+                }
+                return { status: "ok" };
+            }
+            catch (error) {
+                return { status: "failed", reason: describeError(error) };
+            }
         },
         onLifecycleEvent: async (event) => {
             await opts.eventLog.emit("cron_program.lifecycle", {
@@ -93,162 +94,10 @@ export function createServerProgramOrchestration(opts) {
                     program: event.program,
                 },
             });
-            await opts.emitOperatorWake({
-                dedupeKey: `cron-program:${event.program_id}`,
-                message: event.message,
-                payload: {
-                    wake_source: "cron_program",
-                    source_ts_ms: event.ts_ms,
-                    program_id: event.program_id,
-                    status: event.status,
-                    reason: event.reason,
-                    wake_mode: event.program.wake_mode,
-                    target_kind: event.program.target.kind,
-                    target: event.program.target.kind === "run"
-                        ? {
-                            job_id: event.program.target.job_id,
-                            root_issue_id: event.program.target.root_issue_id,
-                        }
-                        : { activity_id: event.program.target.activity_id },
-                },
-            });
         },
     });
-    const findAutoRunHeartbeatProgram = async (jobId) => {
-        const normalizedJobId = jobId.trim();
-        if (!normalizedJobId) {
-            return null;
-        }
-        const knownProgramId = autoRunHeartbeatProgramByJobId.get(normalizedJobId);
-        if (knownProgramId) {
-            const knownProgram = await heartbeatPrograms.get(knownProgramId);
-            if (knownProgram) {
-                return knownProgram;
-            }
-            autoRunHeartbeatProgramByJobId.delete(normalizedJobId);
-        }
-        const programs = await heartbeatPrograms.list({ targetKind: "run", limit: 500 });
-        for (const program of programs) {
-            if (program.metadata.auto_run_job_id !== normalizedJobId) {
-                continue;
-            }
-            autoRunHeartbeatProgramByJobId.set(normalizedJobId, program.program_id);
-            return program;
-        }
-        return null;
-    };
-    const registerAutoRunHeartbeatProgram = async (run) => {
-        if (run.source === "command") {
-            return;
-        }
-        const jobId = run.job_id.trim();
-        if (!jobId || run.status !== "running") {
-            return;
-        }
-        const rootIssueId = typeof run.root_issue_id === "string" ? run.root_issue_id.trim() : "";
-        const metadata = {
-            auto_run_heartbeat: true,
-            auto_run_job_id: jobId,
-            auto_run_root_issue_id: rootIssueId || null,
-            auto_disable_on_terminal: true,
-            run_mode: run.mode,
-            run_source: run.source,
-        };
-        const existing = await findAutoRunHeartbeatProgram(jobId);
-        if (existing) {
-            const result = await heartbeatPrograms.update({
-                programId: existing.program_id,
-                title: `Run heartbeat: ${rootIssueId || jobId}`,
-                target: {
-                    kind: "run",
-                    job_id: jobId,
-                    root_issue_id: rootIssueId || null,
-                },
-                enabled: true,
-                everyMs: opts.autoRunHeartbeatEveryMs,
-                reason: AUTO_RUN_HEARTBEAT_REASON,
-                wakeMode: "next_heartbeat",
-                metadata,
-            });
-            if (result.ok && result.program) {
-                autoRunHeartbeatProgramByJobId.set(jobId, result.program.program_id);
-                await opts.eventLog.emit("run.auto_heartbeat.lifecycle", {
-                    source: "mu-server.runs",
-                    payload: {
-                        action: "updated",
-                        run_job_id: jobId,
-                        run_root_issue_id: rootIssueId || null,
-                        program_id: result.program.program_id,
-                        program: result.program,
-                    },
-                });
-            }
-            return;
-        }
-        const created = await heartbeatPrograms.create({
-            title: `Run heartbeat: ${rootIssueId || jobId}`,
-            target: {
-                kind: "run",
-                job_id: jobId,
-                root_issue_id: rootIssueId || null,
-            },
-            everyMs: opts.autoRunHeartbeatEveryMs,
-            reason: AUTO_RUN_HEARTBEAT_REASON,
-            wakeMode: "next_heartbeat",
-            metadata,
-            enabled: true,
-        });
-        autoRunHeartbeatProgramByJobId.set(jobId, created.program_id);
-        await opts.eventLog.emit("run.auto_heartbeat.lifecycle", {
-            source: "mu-server.runs",
-            payload: {
-                action: "registered",
-                run_job_id: jobId,
-                run_root_issue_id: rootIssueId || null,
-                program_id: created.program_id,
-                program: created,
-            },
-        });
-    };
-    const disableAutoRunHeartbeatProgram = async (disableOpts) => {
-        const program = await findAutoRunHeartbeatProgram(disableOpts.jobId);
-        if (!program) {
-            return;
-        }
-        const metadata = {
-            ...program.metadata,
-            auto_disabled_from_status: disableOpts.status,
-            auto_disabled_reason: disableOpts.reason,
-            auto_disabled_at_ms: Date.now(),
-        };
-        const result = await heartbeatPrograms.update({
-            programId: program.program_id,
-            enabled: false,
-            everyMs: 0,
-            reason: AUTO_RUN_HEARTBEAT_REASON,
-            wakeMode: program.wake_mode,
-            metadata,
-        });
-        autoRunHeartbeatProgramByJobId.delete(disableOpts.jobId.trim());
-        if (!result.ok || !result.program) {
-            return;
-        }
-        await opts.eventLog.emit("run.auto_heartbeat.lifecycle", {
-            source: "mu-server.runs",
-            payload: {
-                action: "disabled",
-                run_job_id: disableOpts.jobId,
-                status: disableOpts.status,
-                reason: disableOpts.reason,
-                program_id: result.program.program_id,
-                program: result.program,
-            },
-        });
-    };
     return {
         heartbeatPrograms,
         cronPrograms,
-        registerAutoRunHeartbeatProgram,
-        disableAutoRunHeartbeatProgram,
     };
 }

package/dist/server_routing.d.ts

@@ -3,7 +3,6 @@ import type { MuConfig } from "./config.js";
 import type { ControlPlaneHandle } from "./control_plane_contract.js";
 import type { CronProgramRegistry } from "./cron_programs.js";
 import type { HeartbeatProgramRegistry } from "./heartbeat_programs.js";
-import type { AutoHeartbeatRunSnapshot } from "./server_program_orchestration.js";
 import type { ServerContext } from "./server.js";
 export type ServerRoutingDependencies = {
     context: ServerContext;
@@ -17,15 +16,7 @@ export type ServerRoutingDependencies = {
         ok: boolean;
     }>;
     getControlPlaneStatus: () => unknown;
-    registerAutoRunHeartbeatProgram: (run: AutoHeartbeatRunSnapshot) => Promise<void>;
-    disableAutoRunHeartbeatProgram: (opts: {
-        jobId: string;
-        status: string;
-        reason: string;
-    }) => Promise<void>;
     describeError: (error: unknown) => string;
     initiateShutdown?: () => Promise<void>;
-    publicDir?: string;
-    mimeTypes?: Record<string, string>;
 };
 export declare function createServerRequestHandler(deps: ServerRoutingDependencies): (request: Request) => Promise<Response>;