agent-mockingbird 0.0.1

package/apps/server/src/backend/http/routes/cronRoutes.ts

@@ -0,0 +1,221 @@
+import type { CronService } from "../../cron/service";
+import { cronJobCreateSchema, cronJobPatchSchema, cronManageSchema } from "../schemas";
+
+export function createCronRoutes(cronService: CronService) {
+  return {
+    "/api/mockingbird/cron/health": {
+      GET: async () => {
+        try {
+          return Response.json({ health: await cronService.getHealth() });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to load cron health";
+          return Response.json({ error: message }, { status: 500 });
+        }
+      },
+    },
+
+    "/api/mockingbird/cron/jobs": {
+      GET: async () => {
+        try {
+          return Response.json({ jobs: await cronService.listJobs() });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to load cron jobs";
+          return Response.json({ error: message }, { status: 500 });
+        }
+      },
+      POST: async (req: Request) => {
+        const parsed = cronJobCreateSchema.safeParse(await req.json());
+        if (!parsed.success) {
+          return Response.json(
+            { error: parsed.error.issues[0]?.message ?? "Invalid cron job payload" },
+            { status: 400 },
+          );
+        }
+        try {
+          const job = await cronService.createJob(parsed.data);
+          return Response.json({ job }, { status: 201 });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to create cron job";
+          return Response.json({ error: message }, { status: 400 });
+        }
+      },
+    },
+
+    "/api/mockingbird/cron/jobs/:id": {
+      GET: async (req: Request & { params: { id: string } }) => {
+        const job = await cronService.getJob(req.params.id);
+        if (!job) {
+          return Response.json({ error: "Unknown cron job" }, { status: 404 });
+        }
+        return Response.json({ job });
+      },
+      PATCH: async (req: Request & { params: { id: string } }) => {
+        const parsed = cronJobPatchSchema.safeParse(await req.json());
+        if (!parsed.success) {
+          return Response.json(
+            { error: parsed.error.issues[0]?.message ?? "Invalid cron job patch payload" },
+            { status: 400 },
+          );
+        }
+        try {
+          const job = await cronService.updateJob(req.params.id, parsed.data);
+          return Response.json({ job });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to update cron job";
+          const status = message.startsWith("Unknown cron job:") ? 404 : 400;
+          return Response.json({ error: message }, { status });
+        }
+      },
+      DELETE: async (req: Request & { params: { id: string } }) => {
+        const result = await cronService.deleteJob(req.params.id);
+        if (!result.removed) {
+          return Response.json({ error: "Unknown cron job" }, { status: 404 });
+        }
+        return Response.json(result);
+      },
+    },
+
+    "/api/mockingbird/cron/jobs/:id/run": {
+      POST: async (req: Request & { params: { id: string } }) => {
+        try {
+          const run = await cronService.runJobNow(req.params.id);
+          return Response.json(run, { status: run.queued ? 202 : 409 });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to queue cron run";
+          const status = message.startsWith("Unknown cron job:") ? 404 : 400;
+          return Response.json({ error: message }, { status });
+        }
+      },
+    },
+
+    "/api/mockingbird/cron/instances": {
+      GET: async (req: Request) => {
+        try {
+          const url = new URL(req.url);
+          const jobId = url.searchParams.get("jobId")?.trim() || undefined;
+          const limitRaw = url.searchParams.get("limit");
+          const limit = limitRaw ? Number(limitRaw) : undefined;
+          const instances = await cronService.listInstances({
+            jobId,
+            limit: typeof limit === "number" && Number.isFinite(limit) ? limit : undefined,
+          });
+          return Response.json({ instances });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to load cron instances";
+          return Response.json({ error: message }, { status: 400 });
+        }
+      },
+    },
+
+    "/api/mockingbird/cron/instances/:id/steps": {
+      GET: async (req: Request & { params: { id: string } }) => {
+        try {
+          const steps = await cronService.listSteps(req.params.id);
+          return Response.json({ steps });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to load cron steps";
+          return Response.json({ error: message }, { status: 400 });
+        }
+      },
+    },
+
+    "/api/mockingbird/cron/manage": {
+      POST: async (req: Request) => {
+        const parsed = cronManageSchema.safeParse(await req.json());
+        if (!parsed.success) {
+          return Response.json(
+            { error: parsed.error.issues[0]?.message ?? "Invalid cron manage request" },
+            { status: 400 },
+          );
+        }
+        try {
+          const command = parsed.data;
+          switch (command.action) {
+            case "list_jobs":
+              return Response.json({ ok: true, action: command.action, jobs: await cronService.listJobs() });
+            case "health":
+              return Response.json({ ok: true, action: command.action, health: await cronService.getHealth() });
+            case "get_job": {
+              const job = await cronService.getJob(command.jobId);
+              if (!job) {
+                return Response.json({ error: "Unknown cron job" }, { status: 404 });
+              }
+              return Response.json({ ok: true, action: command.action, job });
+            }
+            case "create_job":
+              return Response.json(
+                { ok: true, action: command.action, job: await cronService.createJob(command.job) },
+                { status: 201 },
+              );
+            case "upsert_job": {
+              const upserted = await cronService.upsertJob(command.job);
+              return Response.json({
+                ok: true,
+                action: command.action,
+                created: upserted.created,
+                job: upserted.job,
+              });
+            }
+            case "update_job":
+              return Response.json({
+                ok: true,
+                action: command.action,
+                job: await cronService.updateJob(command.jobId, command.patch),
+              });
+            case "enable_job":
+              return Response.json({
+                ok: true,
+                action: command.action,
+                job: await cronService.updateJob(command.jobId, { enabled: true }),
+              });
+            case "disable_job":
+              return Response.json({
+                ok: true,
+                action: command.action,
+                job: await cronService.updateJob(command.jobId, { enabled: false }),
+              });
+            case "describe_contract":
+              return Response.json({
+                ok: true,
+                action: command.action,
+                contract: cronService.describeContract(),
+              });
+            case "delete_job":
+              return Response.json({
+                ok: true,
+                action: command.action,
+                ...(await cronService.deleteJob(command.jobId)),
+              });
+            case "run_job_now":
+              return Response.json({
+                ok: true,
+                action: command.action,
+                ...(await cronService.runJobNow(command.jobId)),
+              });
+            case "list_instances":
+              return Response.json({
+                ok: true,
+                action: command.action,
+                instances: await cronService.listInstances({
+                  jobId: command.jobId,
+                  limit: command.limit,
+                }),
+              });
+            case "list_steps":
+              return Response.json({
+                ok: true,
+                action: command.action,
+                steps: await cronService.listSteps(command.instanceId),
+              });
+            default:
+              return Response.json({ error: "Unsupported cron action" }, { status: 400 });
+          }
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Cron manage request failed";
+          const status = message.startsWith("Unknown cron job:") ? 404 : 400;
+          return Response.json({ error: message }, { status });
+        }
+      },
+    },
+  };
+}

package/apps/server/src/backend/http/routes/dashboardRoutes.ts

@@ -0,0 +1,308 @@
+import { buildWorkspaceBootstrapPromptContext } from "../../agents/bootstrapContext";
+import { getOpencodeAgentStorageInfo } from "../../agents/opencodeConfig";
+import { applyConfigPatch, ConfigApplyError, getConfigSnapshot } from "../../config/service";
+import type { RuntimeEngine } from "../../contracts/runtime";
+import {
+  createSession,
+  getDashboardBootstrap,
+  getSessionById,
+  listMessagesForSession,
+  listSessions,
+  setSessionModel,
+} from "../../db/repository";
+import { listOpencodeModelOptions } from "../../opencode/models";
+import { getRuntimeStartupInfo } from "../../runtime";
+import { resolveWorkspaceAlignment } from "../../workspace/resolve";
+
+function parseModelSelection(model: string, defaultProviderId: string) {
+  const trimmed = model.trim();
+  if (!trimmed) return null;
+  if (!trimmed.includes("/")) {
+    const providerId = defaultProviderId.trim();
+    if (!providerId) return null;
+    return { providerId, modelId: trimmed };
+  }
+  const [providerPart = "", ...rest] = trimmed.split("/");
+  const providerId = providerPart.trim();
+  const modelId = rest.join("/").trim();
+  if (!providerId || !modelId) return null;
+  return { providerId, modelId };
+}
+
+function toQualifiedModel(providerId: string, modelId: string) {
+  const provider = providerId.trim();
+  const model = modelId.trim();
+  if (!provider || !model) return "";
+  return `${provider}/${model}`;
+}
+
+function toConfigErrorResponse(error: unknown) {
+  if (error instanceof ConfigApplyError) {
+    if (error.stage === "conflict") {
+      return {
+        status: 409,
+        body: { error: error.message, stage: error.stage },
+      };
+    }
+    if (error.stage === "request" || error.stage === "schema") {
+      return {
+        status: 400,
+        body: { error: error.message, stage: error.stage, details: error.details },
+      };
+    }
+    if (error.stage === "semantic" || error.stage === "smoke" || error.stage === "policy") {
+      return {
+        status: 422,
+        body: { error: error.message, stage: error.stage, details: error.details },
+      };
+    }
+    return {
+      status: 500,
+      body: { error: error.message, stage: error.stage },
+    };
+  }
+
+  return {
+    status: 500,
+    body: {
+      error: error instanceof Error ? error.message : "Failed to update runtime model defaults",
+      stage: "unknown",
+    },
+  };
+}
+
+export function createDashboardRoutes(runtime: RuntimeEngine) {
+  return {
+    "/api/health": {
+      GET: () =>
+        Response.json({
+          status: "ok",
+          now: new Date().toISOString(),
+        }),
+    },
+
+    "/api/dashboard/bootstrap": {
+      GET: () => Response.json(getDashboardBootstrap()),
+    },
+
+    "/api/runtime/health": {
+      GET: async (req: Request) => {
+        if (!runtime.checkHealth) {
+          return Response.json({ error: "Runtime health checks are not supported by this runtime" }, { status: 501 });
+        }
+
+        const force = (() => {
+          const value = new URL(req.url).searchParams.get("force");
+          if (!value) return false;
+          const normalized = value.trim().toLowerCase();
+          return normalized === "1" || normalized === "true" || normalized === "yes";
+        })();
+
+        try {
+          const health = await runtime.checkHealth({ force });
+          return Response.json({ health }, { status: health.ok ? 200 : 503 });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Runtime health check failed";
+          return Response.json({ error: message }, { status: 503 });
+        }
+      },
+    },
+
+    "/api/runtime/info": {
+      GET: () => {
+        const snapshot = getConfigSnapshot();
+        const runtimeInfo = getRuntimeStartupInfo();
+        const storage = getOpencodeAgentStorageInfo();
+        const bootstrap = buildWorkspaceBootstrapPromptContext();
+        const workspaceAlignment = resolveWorkspaceAlignment(snapshot.config);
+        return Response.json({
+          configAuthority: {
+            source: "agent-mockingbird-config-json",
+            path: snapshot.path,
+            hash: snapshot.hash,
+          },
+          opencode: {
+            ...runtimeInfo.opencode,
+            workspaceDirectory: storage.workspaceDirectory,
+            configDirectory: storage.configDirectory,
+            effectiveConfigPath: storage.configFilePath,
+            persistenceMode: storage.persistenceMode,
+            projection: {
+              source: "agent-mockingbird-config-json",
+              syncs: ["small_model", "skills.paths", "mcp", "agent"],
+            },
+            identity: bootstrap.identity,
+            bootstrap: {
+              mode: bootstrap.mode,
+              files: bootstrap.files.map(file => ({
+                name: file.name,
+                path: file.path,
+                missing: file.missing,
+                truncated: file.truncated,
+                originalLength: file.originalLength,
+                injectedLength: file.content.length,
+              })),
+            },
+            workspace: {
+              aligned: workspaceAlignment.aligned,
+              opencodeDirectoryExplicit: workspaceAlignment.opencodeDirectoryExplicit,
+              opencodeWorkspaceDir: workspaceAlignment.opencodeWorkspaceDir,
+              opencodeConfigDir: storage.configDirectory,
+              memoryWorkspaceDir: workspaceAlignment.memoryWorkspaceDir,
+            },
+          },
+        });
+      },
+    },
+
+    "/api/sessions": {
+      GET: () => Response.json({ sessions: listSessions() }),
+      POST: async (req: Request) => {
+        const body = (await req.json()) as { title?: string; model?: string } | null;
+        const session = createSession({
+          title: body?.title,
+          model: body?.model,
+        });
+        return Response.json({ session }, { status: 201 });
+      },
+    },
+
+    "/api/sessions/:id/messages": (req: Request & { params: { id: string } }) => {
+      const sessionId = req.params.id;
+      const session = getSessionById(sessionId);
+      if (!session) {
+        return Response.json({ error: "Unknown session" }, { status: 404 });
+      }
+      return (async () => {
+        if (runtime.syncSessionMessages) {
+          try {
+            await runtime.syncSessionMessages(sessionId);
+          } catch {
+            // degrade gracefully; return best-effort local transcript
+          }
+        }
+        return Response.json({
+          sessionId,
+          messages: listMessagesForSession(sessionId),
+        });
+      })();
+    },
+
+    "/api/sessions/:id/model": {
+      PUT: async (req: Request & { params: { id: string } }) => {
+        const sessionId = req.params.id;
+        const body = (await req.json()) as { model?: string };
+        const model = body.model?.trim();
+        if (!model) {
+          return Response.json({ error: "model is required" }, { status: 400 });
+        }
+        if (!getSessionById(sessionId)) {
+          return Response.json({ error: "Unknown session" }, { status: 404 });
+        }
+
+        const session = setSessionModel(sessionId, model);
+        if (!session) {
+          return Response.json({ error: "Unknown session" }, { status: 404 });
+        }
+
+        const snapshot = getConfigSnapshot();
+        const currentRuntimeDefaultModel = toQualifiedModel(
+          snapshot.config.runtime.opencode.providerId,
+          snapshot.config.runtime.opencode.modelId,
+        );
+        const parsed = parseModelSelection(model, snapshot.config.runtime.opencode.providerId);
+        if (!parsed) {
+          return Response.json({
+            session,
+            runtimeDefaultModel: currentRuntimeDefaultModel,
+            sessionMatchesRuntimeDefault: session.model === currentRuntimeDefaultModel,
+          });
+        }
+
+        try {
+          const configResult = await applyConfigPatch({
+            expectedHash: snapshot.hash,
+            runSmokeTest: false,
+            patch: {
+              runtime: {
+                opencode: {
+                  providerId: parsed.providerId,
+                  modelId: parsed.modelId,
+                },
+              },
+            },
+          });
+
+          const runtimeDefaultModel = toQualifiedModel(parsed.providerId, parsed.modelId);
+          return Response.json({
+            session,
+            configHash: configResult.snapshot.hash,
+            runtimeDefaultModel,
+            sessionMatchesRuntimeDefault: session.model === runtimeDefaultModel,
+          });
+        } catch (error) {
+          const details = toConfigErrorResponse(error);
+          return Response.json({
+            session,
+            configError: details.body.error,
+            configStage: details.body.stage,
+            runtimeDefaultModel: currentRuntimeDefaultModel,
+            sessionMatchesRuntimeDefault: session.model === currentRuntimeDefaultModel,
+          });
+        }
+      },
+    },
+
+    "/api/runtime/default-model": {
+      PUT: async (req: Request) => {
+        const body = (await req.json()) as { model?: string };
+        const model = body.model?.trim();
+        if (!model) {
+          return Response.json({ error: "model is required" }, { status: 400 });
+        }
+        const snapshot = getConfigSnapshot();
+        const parsed = parseModelSelection(model, snapshot.config.runtime.opencode.providerId);
+        if (!parsed) {
+          return Response.json({ error: "Invalid model format" }, { status: 400 });
+        }
+        try {
+          const configResult = await applyConfigPatch({
+            expectedHash: snapshot.hash,
+            runSmokeTest: false,
+            patch: {
+              runtime: {
+                opencode: {
+                  providerId: parsed.providerId,
+                  modelId: parsed.modelId,
+                },
+              },
+            },
+          });
+          const runtimeDefaultModel = toQualifiedModel(parsed.providerId, parsed.modelId);
+          return Response.json({
+            runtimeDefaultModel,
+            configHash: configResult.snapshot.hash,
+          });
+        } catch (error) {
+          const details = toConfigErrorResponse(error);
+          return Response.json(
+            { error: details.body.error, stage: details.body.stage },
+            { status: details.status },
+          );
+        }
+      },
+    },
+
+    "/api/opencode/models": {
+      GET: async () => {
+        try {
+          const models = await listOpencodeModelOptions();
+          return Response.json({ models });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to load models";
+          return Response.json({ models: [], error: message }, { status: 502 });
+        }
+      },
+    },
+  };
+}

package/apps/server/src/backend/http/routes/eventRoutes.ts

@@ -0,0 +1,7 @@
+import type { RuntimeEventStream } from "../sse";
+
+export function createEventRoutes(eventStream: RuntimeEventStream) {
+  return {
+    "/api/events": eventStream.route,
+  };
+}

package/apps/server/src/backend/http/routes/heartbeatRoutes.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+
+import { createHeartbeatRoutes } from "./heartbeatRoutes";
+
+describe("heartbeat routes", () => {
+  test("GET /api/mockingbird/heartbeat returns session metadata", async () => {
+    const routes = createHeartbeatRoutes({
+      getStatus: () => ({
+        config: {
+          enabled: true,
+          interval: "30m",
+          agentId: "build",
+          model: "opencode/big-pickle",
+          prompt: "Read HEARTBEAT.md",
+          ackMaxChars: 300,
+          activeHours: null,
+        },
+        state: {
+          sessionId: "session-heartbeat",
+          running: false,
+          lastRunAt: "2026-03-20T00:00:00.000Z",
+          lastResult: "acknowledged",
+          lastResponse: null,
+          lastError: null,
+          updatedAt: "2026-03-20T00:00:00.000Z",
+        },
+        sessionTitle: "Heartbeat",
+        nextDueAt: "2026-03-20T00:30:00.000Z",
+      }),
+    } as never);
+
+    const response = await routes["/api/mockingbird/heartbeat"].GET();
+    expect(response.status).toBe(200);
+
+    const payload = (await response.json()) as {
+      heartbeat: { state: { sessionId: string | null }; sessionTitle: string | null };
+    };
+    expect(payload.heartbeat.state.sessionId).toBe("session-heartbeat");
+    expect(payload.heartbeat.sessionTitle).toBe("Heartbeat");
+  });
+});

package/apps/server/src/backend/http/routes/heartbeatRoutes.ts

@@ -0,0 +1,28 @@
+import type { HeartbeatRuntimeService } from "../../heartbeat/runtimeService";
+
+export function createHeartbeatRoutes(heartbeatService: HeartbeatRuntimeService) {
+  return {
+    "/api/mockingbird/heartbeat": {
+      GET: async () => {
+        try {
+          return Response.json({ heartbeat: heartbeatService.getStatus() });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to load heartbeat status";
+          return Response.json({ error: message }, { status: 500 });
+        }
+      },
+    },
+
+    "/api/mockingbird/heartbeat/run": {
+      POST: async () => {
+        try {
+          const heartbeat = await heartbeatService.runNow();
+          return Response.json({ heartbeat }, { status: 202 });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to run heartbeat";
+          return Response.json({ error: message }, { status: 500 });
+        }
+      },
+    },
+  };
+}