agent-mockingbird 0.0.1

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

@@ -0,0 +1,310 @@
+import { getConfigSnapshot } from "../../config/service";
+import type { RuntimeInputPart } from "../../contracts/runtime";
+import { getSessionById } from "../../db/repository";
+import { createLogger } from "../../logging/logger";
+import type { RunService } from "../../run/service";
+import type { AgentRunEvent } from "../../run/types";
+import { createBoundedQueue, type BoundedQueue } from "../boundedQueue";
+
+const RUN_STREAM_MAX_QUEUED_FRAMES = 256;
+const RUN_STREAM_DRAIN_DELAY_MS = 25;
+const logger = createLogger("run-event-stream");
+
+function runStreamConfig() {
+  return getConfigSnapshot().config.runtime.runStream;
+}
+
+function parseAfterSeq(req: Request) {
+  const url = new URL(req.url);
+  const queryRaw = url.searchParams.get("afterSeq") ?? url.searchParams.get("after");
+  const headerRaw = req.headers.get("last-event-id");
+  const queryAfter = Number(queryRaw);
+  const headerAfter = Number(headerRaw);
+  const normalizedQuery = Number.isFinite(queryAfter) ? Math.max(0, Math.floor(queryAfter)) : 0;
+  const normalizedHeader = Number.isFinite(headerAfter) ? Math.max(0, Math.floor(headerAfter)) : 0;
+  return Math.max(normalizedQuery, normalizedHeader);
+}
+
+function toRunEventFrame(event: AgentRunEvent) {
+  return `id: ${event.seq}\nevent: run-event\ndata: ${JSON.stringify(event)}\n\n`;
+}
+
+function toRunHeartbeatFrame(runId: string) {
+  return `event: run-heartbeat\ndata: ${JSON.stringify({ runId, at: new Date().toISOString() })}\n\n`;
+}
+
+function normalizeRuntimeInputParts(value: unknown): RuntimeInputPart[] {
+  if (!Array.isArray(value)) return [];
+  const parts: RuntimeInputPart[] = [];
+  for (const raw of value) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+    const record = raw as Record<string, unknown>;
+    if (record.type === "text") {
+      const text = typeof record.text === "string" ? record.text : "";
+      if (!text.trim()) continue;
+      parts.push({
+        type: "text",
+        text,
+      });
+      continue;
+    }
+    if (record.type === "file") {
+      const mime = typeof record.mime === "string" ? record.mime.trim() : "";
+      const url = typeof record.url === "string" ? record.url.trim() : "";
+      const filename = typeof record.filename === "string" ? record.filename.trim() || undefined : undefined;
+      if (!mime || !url) continue;
+      parts.push({
+        type: "file",
+        mime,
+        url,
+        filename,
+      });
+    }
+  }
+  return parts;
+}
+
+export function createRunRoutes(runService: RunService) {
+  return {
+    "/api/runs": {
+      POST: async (req: Request) => {
+        const body = (await req.json()) as {
+          sessionId?: string;
+          content?: string;
+          parts?: RuntimeInputPart[];
+          agent?: string;
+          metadata?: Record<string, unknown>;
+          idempotencyKey?: string;
+        };
+
+        const sessionId = body.sessionId?.trim();
+        const content = body.content?.trim();
+        const parts = normalizeRuntimeInputParts(body.parts);
+        if (!sessionId || (!content && parts.length === 0)) {
+          return Response.json({ error: "sessionId and content or parts are required" }, { status: 400 });
+        }
+        if (!getSessionById(sessionId)) {
+          return Response.json({ error: "Unknown session" }, { status: 404 });
+        }
+
+        const metadata =
+          body.metadata && typeof body.metadata === "object" && !Array.isArray(body.metadata)
+            ? body.metadata
+            : undefined;
+        const agent = typeof body.agent === "string" ? body.agent.trim() || undefined : undefined;
+        const idempotencyKey = body.idempotencyKey?.trim() || undefined;
+
+        try {
+          const result = runService.createRun({
+            sessionId,
+            content: content ?? "",
+            parts,
+            agent,
+            metadata,
+            idempotencyKey,
+          });
+          return Response.json(
+            {
+              accepted: true,
+              deduplicated: result.deduplicated,
+              runId: result.run.id,
+              run: result.run,
+            },
+            { status: result.deduplicated ? 200 : 202 },
+          );
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to queue run";
+          if (message.startsWith("Unknown session:")) {
+            return Response.json({ error: "Unknown session" }, { status: 404 });
+          }
+          return Response.json({ error: message }, { status: 400 });
+        }
+      },
+    },
+
+    "/api/runs/:id": {
+      GET: async (req: Request & { params: { id: string } }) => {
+        const run = runService.getRunById(req.params.id);
+        if (!run) {
+          return Response.json({ error: "Unknown run" }, { status: 404 });
+        }
+        return Response.json({ run });
+      },
+    },
+
+    "/api/runs/:id/events": {
+      GET: async (req: Request & { params: { id: string } }) => {
+        const run = runService.getRunById(req.params.id);
+        if (!run) {
+          return Response.json({ error: "Unknown run" }, { status: 404 });
+        }
+
+        const url = new URL(req.url);
+        const afterRaw = url.searchParams.get("afterSeq") ?? url.searchParams.get("after") ?? "0";
+        const limitRaw = url.searchParams.get("limit") ?? "100";
+        const afterSeq = Number(afterRaw);
+        const limit = Number(limitRaw);
+
+        const replay = runService.listRunEvents({
+          runId: run.id,
+          afterSeq: Number.isFinite(afterSeq) ? afterSeq : 0,
+          limit: Number.isFinite(limit) ? limit : 100,
+        });
+
+        return Response.json({
+          runId: run.id,
+          afterSeq: Number.isFinite(afterSeq) ? Math.max(0, Math.floor(afterSeq)) : 0,
+          events: replay.events,
+          nextAfterSeq: replay.nextAfterSeq,
+          hasMore: replay.hasMore,
+        });
+      },
+    },
+
+    "/api/runs/:id/events/stream": {
+      GET: (req: Request & { params: { id: string } }) => {
+        const run = runService.getRunById(req.params.id);
+        if (!run) {
+          return Response.json({ error: "Unknown run" }, { status: 404 });
+        }
+
+        const runId = run.id;
+        const initialAfterSeq = parseAfterSeq(req);
+
+        let streamController: ReadableStreamDefaultController<string> | null = null;
+        let unsubscribe: (() => void) | null = null;
+        let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+        let outboundQueue: BoundedQueue<string> | null = null;
+        let closed = false;
+        let cursor = initialAfterSeq;
+
+        const close = () => {
+          if (closed) return;
+          closed = true;
+          outboundQueue?.close();
+          outboundQueue = null;
+          if (heartbeatTimer) {
+            clearInterval(heartbeatTimer);
+            heartbeatTimer = null;
+          }
+          if (unsubscribe) {
+            unsubscribe();
+            unsubscribe = null;
+          }
+          if (streamController) {
+            try {
+              streamController.close();
+            } catch {
+              // stream already closed
+            }
+            streamController = null;
+          }
+        };
+
+        const emit = (event: AgentRunEvent) => {
+          if (closed || !outboundQueue) return;
+          if (event.seq <= cursor) return;
+          cursor = event.seq;
+          outboundQueue.enqueue(toRunEventFrame(event));
+          if (event.type === "run.completed" || event.type === "run.failed") {
+            if (outboundQueue.size() === 0) {
+              close();
+              return;
+            }
+            setTimeout(() => {
+              close();
+            }, RUN_STREAM_DRAIN_DELAY_MS * 2);
+          }
+        };
+
+        const stream = new ReadableStream<string>({
+          async start(controller) {
+            streamController = controller;
+            outboundQueue = createBoundedQueue<string>({
+              maxSize: RUN_STREAM_MAX_QUEUED_FRAMES,
+              drainDelayMs: RUN_STREAM_DRAIN_DELAY_MS,
+              tryWrite: (value) => {
+                if (controller.desiredSize !== null && controller.desiredSize <= 0) {
+                  return false;
+                }
+                controller.enqueue(value);
+                return true;
+              },
+              onOverflow: () => {
+                logger.warn("Closing run SSE consumer", {
+                  runId,
+                  reason: "outbound queue overflow",
+                });
+                close();
+              },
+              onWriteError: (error) => {
+                logger.warnWithCause("Closing run SSE consumer", error, {
+                  runId,
+                  reason: "write failure",
+                });
+                close();
+              },
+            });
+            unsubscribe = runService.subscribe(event => {
+              if (event.runId !== runId) return;
+              emit(event);
+            });
+
+            while (!closed) {
+              const replay = runService.listRunEvents({
+                runId,
+                afterSeq: cursor,
+                limit: runStreamConfig().replayPageSize,
+              });
+              if (!replay.events.length) break;
+              for (const event of replay.events) {
+                emit(event);
+                if (closed) return;
+              }
+              if (!replay.hasMore) break;
+            }
+
+            if (closed) return;
+            const latestRun = runService.getRunById(runId);
+            if (latestRun?.state === "completed" || latestRun?.state === "failed") {
+              const deadlineAt = Date.now() + RUN_STREAM_DRAIN_DELAY_MS * 10;
+              while (!closed) {
+                const finalReplay = runService.listRunEvents({
+                  runId,
+                  afterSeq: cursor,
+                  limit: runStreamConfig().replayPageSize,
+                });
+                for (const event of finalReplay.events) {
+                  emit(event);
+                  if (closed) return;
+                }
+                if (finalReplay.events.length > 0 || Date.now() >= deadlineAt) {
+                  break;
+                }
+                await new Promise(resolve => setTimeout(resolve, RUN_STREAM_DRAIN_DELAY_MS));
+              }
+              close();
+              return;
+            }
+
+            heartbeatTimer = setInterval(() => {
+              if (closed || !outboundQueue) return;
+              outboundQueue.enqueue(toRunHeartbeatFrame(runId));
+            }, runStreamConfig().heartbeatMs);
+          },
+          cancel() {
+            close();
+          },
+        });
+
+        return new Response(stream, {
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache, no-transform",
+            Connection: "keep-alive",
+          },
+        });
+      },
+    },
+  };
+}

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

@@ -0,0 +1,197 @@
+import { z } from "zod";
+
+import { getOpencodeAgentStorageInfo } from "../../agents/opencodeConfig";
+import { applyConfigPatch, getConfigSnapshot, replaceConfig } from "../../config/service";
+import type { CronService } from "../../cron/service";
+import {
+  buildAgentMockingbirdCompactionPrompt,
+  buildAgentMockingbirdCompactionContext,
+  buildAgentMockingbirdSystemPrompt,
+} from "../../opencode/systemPrompt";
+import { resolveRuntimeSessionScope } from "../../runtime/sessionScope";
+
+const runtimePatchSchema = z
+  .object({
+    workspace: z
+      .object({
+        pinnedDirectory: z.string().min(1).optional(),
+      })
+      .partial()
+      .optional(),
+    runtime: z
+      .object({
+        memory: z.record(z.string(), z.unknown()).optional(),
+        heartbeat: z.record(z.string(), z.unknown()).optional(),
+        cron: z.record(z.string(), z.unknown()).optional(),
+      })
+      .partial()
+      .optional(),
+  })
+  .strict();
+
+function buildRuntimePayload() {
+  const snapshot = getConfigSnapshot();
+  return {
+    hash: snapshot.hash,
+    path: snapshot.path,
+    config: {
+      workspace: snapshot.config.workspace,
+      runtime: {
+        memory: snapshot.config.runtime.memory,
+        heartbeat: snapshot.config.runtime.heartbeat,
+        cron: snapshot.config.runtime.cron,
+      },
+    },
+  };
+}
+
+export function createRuntimeRoutes(input: { cronService: CronService }) {
+  return {
+    "/api/mockingbird/runtime/pinned-workspace": {
+      GET: () => {
+        const snapshot = getConfigSnapshot();
+        return Response.json({
+          directory: snapshot.config.workspace.pinnedDirectory,
+          hash: snapshot.hash,
+        });
+      },
+    },
+
+    "/api/mockingbird/runtime/config": {
+      GET: () => Response.json(buildRuntimePayload()),
+      PATCH: async (req: Request) => {
+        const body = (await req.json()) as Record<string, unknown>;
+        const parsed = runtimePatchSchema.safeParse(body.patch ?? body);
+        if (!parsed.success) {
+          return Response.json(
+            { error: parsed.error.issues[0]?.message ?? "Invalid runtime config patch" },
+            { status: 400 },
+          );
+        }
+
+        try {
+          const result = await applyConfigPatch({
+            patch: parsed.data,
+            expectedHash: typeof body.expectedHash === "string" ? body.expectedHash : undefined,
+            runSmokeTest: false,
+          });
+          return Response.json({
+            ...buildRuntimePayload(),
+            hash: result.snapshot.hash,
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to update runtime config";
+          const status = message.includes("refresh and retry") ? 409 : 400;
+          return Response.json({ error: message }, { status });
+        }
+      },
+    },
+
+    "/api/mockingbird/runtime/config/replace": {
+      POST: async (req: Request) => {
+        const body = (await req.json()) as { config?: unknown; expectedHash?: unknown };
+        try {
+          const result = await replaceConfig({
+            config: body.config,
+            expectedHash: typeof body.expectedHash === "string" ? body.expectedHash : undefined,
+            runSmokeTest: false,
+          });
+          return Response.json({
+            ...buildRuntimePayload(),
+            hash: result.snapshot.hash,
+          });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to replace runtime config";
+          const status = message.includes("refresh and retry") ? 409 : 400;
+          return Response.json({ error: message }, { status });
+        }
+      },
+    },
+
+    "/api/mockingbird/runtime/info": {
+      GET: () => {
+        const snapshot = getConfigSnapshot();
+        const storage = getOpencodeAgentStorageInfo(snapshot.config);
+        return Response.json({
+          hash: snapshot.hash,
+          path: snapshot.path,
+          pinnedWorkspace: snapshot.config.workspace.pinnedDirectory,
+          opencode: {
+            baseUrl: snapshot.config.runtime.opencode.baseUrl,
+            workspaceDirectory: snapshot.config.runtime.opencode.directory,
+            configDirectory: storage.configDirectory,
+            effectiveConfigPath: storage.configFilePath,
+            timeoutMs: snapshot.config.runtime.opencode.timeoutMs,
+          },
+        });
+      },
+    },
+
+    "/api/mockingbird/runtime/system-prompt": {
+      GET: () =>
+        Response.json({
+          system: buildAgentMockingbirdSystemPrompt() ?? "",
+        }),
+    },
+
+    "/api/mockingbird/runtime/compaction-context": {
+      GET: (req: Request) => {
+        const sessionId = new URL(req.url).searchParams.get("sessionId")?.trim() || undefined;
+        return Response.json({
+          prompt: buildAgentMockingbirdCompactionPrompt(sessionId),
+          context: buildAgentMockingbirdCompactionContext(sessionId),
+        });
+      },
+    },
+
+    "/api/mockingbird/runtime/session-scope": {
+      GET: (req: Request) => {
+        const sessionId = new URL(req.url).searchParams.get("sessionId")?.trim() ?? "";
+        if (!sessionId) {
+          return Response.json({ error: "sessionId is required" }, { status: 400 });
+        }
+
+        return Response.json(resolveRuntimeSessionScope(sessionId, input.cronService));
+      },
+    },
+
+    "/api/mockingbird/runtime/notify-main-thread": {
+      POST: async (req: Request) => {
+        const body = (await req.json()) as {
+          sessionId?: unknown;
+          prompt?: unknown;
+          severity?: unknown;
+        };
+        const sessionId = typeof body.sessionId === "string" ? body.sessionId.trim() : "";
+        const prompt = typeof body.prompt === "string" ? body.prompt.trim() : "";
+        const severity =
+          body.severity === "info" || body.severity === "warn" || body.severity === "critical"
+            ? body.severity
+            : undefined;
+        if (!sessionId) {
+          return Response.json({ error: "sessionId is required" }, { status: 400 });
+        }
+        if (!prompt) {
+          return Response.json({ error: "prompt is required" }, { status: 400 });
+        }
+
+        try {
+          const result = await input.cronService.notifyMainThread({
+            runtimeSessionId: sessionId,
+            prompt,
+            severity,
+          });
+          return Response.json({ ok: true, ...result });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to notify main thread";
+          const status =
+            message === "Unknown runtime session" ||
+            message === "notify_main_thread is only available from cron or heartbeat threads"
+              ? 403
+              : 400;
+          return Response.json({ error: message }, { status });
+        }
+      },
+    },
+  };
+}

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

@@ -0,0 +1,112 @@
+import {
+  importManagedSkillWithConfigUpdate,
+  loadRuntimeSkillCatalog,
+  setEnabledSkillsFromCatalog,
+} from "../../config/orchestration";
+import { getConfigSnapshot } from "../../config/service";
+import {
+  disposeOpencodeSkillInstance,
+  getDisabledSkillsRootPath,
+  getManagedSkillsRootPath,
+  listManagedSkillCatalog,
+  removeManagedSkill,
+  setManagedSkillEnabled,
+} from "../../skills/service";
+
+export function createSkillRoutes() {
+  return {
+    "/api/mockingbird/skills": {
+      GET: async () => {
+        const result = await loadRuntimeSkillCatalog();
+        return Response.json(result.payload, { status: result.status });
+      },
+    },
+
+    "/api/mockingbird/skills/import": {
+      POST: async (req: Request) => {
+        const body = (await req.json()) as {
+          id?: string;
+          content?: string;
+          enable?: boolean;
+          expectedHash?: string;
+        };
+        if (!body.id?.trim() || !body.content?.trim()) {
+          return Response.json({ error: "id and content are required" }, { status: 400 });
+        }
+        try {
+          const result = await importManagedSkillWithConfigUpdate({
+            rawId: body.id,
+            content: body.content,
+            enable: body.enable !== false,
+            expectedHash: body.expectedHash,
+          });
+          return Response.json(result, { status: 201 });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to import skill";
+          const status = message.includes("refresh and retry") ? 409 : 400;
+          return Response.json({ error: message }, { status });
+        }
+      },
+    },
+
+    "/api/mockingbird/skills/enabled": {
+      PUT: async (req: Request) => {
+        const body = (await req.json()) as { skills?: unknown; expectedHash?: string };
+        if (!Array.isArray(body.skills)) {
+          return Response.json({ error: "skills must be an array" }, { status: 400 });
+        }
+        try {
+          const result = await setEnabledSkillsFromCatalog({
+            skills: body.skills.filter((value): value is string => typeof value === "string"),
+            expectedHash: body.expectedHash,
+          });
+          return Response.json(result);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to update skills";
+          const status = message.includes("refresh and retry") ? 409 : 400;
+          return Response.json({ error: message }, { status });
+        }
+      },
+    },
+
+    "/api/mockingbird/skills/:id": {
+      PATCH: async (req: Request & { params: { id: string } }) => {
+        const body = (await req.json()) as { enabled?: unknown };
+        if (typeof body.enabled !== "boolean") {
+          return Response.json({ error: "enabled must be a boolean" }, { status: 400 });
+        }
+        const snapshot = getConfigSnapshot();
+        setManagedSkillEnabled(req.params.id, body.enabled, snapshot.config.workspace.pinnedDirectory);
+        await disposeOpencodeSkillInstance(snapshot.config);
+        const catalog = listManagedSkillCatalog(snapshot.config.workspace.pinnedDirectory);
+        return Response.json({
+          skills: catalog.skills,
+          enabled: catalog.enabled,
+          disabled: catalog.disabled,
+          invalid: catalog.invalid,
+          hash: catalog.revision,
+          revision: catalog.revision,
+          managedPath: getManagedSkillsRootPath(snapshot.config.workspace.pinnedDirectory),
+          disabledPath: getDisabledSkillsRootPath(snapshot.config.workspace.pinnedDirectory),
+        });
+      },
+      DELETE: async (req: Request & { params: { id: string } }) => {
+        const snapshot = getConfigSnapshot();
+        removeManagedSkill(req.params.id, snapshot.config.workspace.pinnedDirectory);
+        await disposeOpencodeSkillInstance(snapshot.config);
+        const catalog = listManagedSkillCatalog(snapshot.config.workspace.pinnedDirectory);
+        return Response.json({
+          removed: true,
+          skills: catalog.skills,
+          enabled: catalog.enabled,
+          disabled: catalog.disabled,
+          invalid: catalog.invalid,
+          hash: catalog.revision,
+          revision: catalog.revision,
+          managedPath: getManagedSkillsRootPath(snapshot.config.workspace.pinnedDirectory),
+          disabledPath: getDisabledSkillsRootPath(snapshot.config.workspace.pinnedDirectory),
+        });
+      },
+    },
+  };
+}