agent-mockingbird 0.0.1

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

@@ -0,0 +1,101 @@
+import { z } from "zod";
+
+import { migrateOpenclawWorkspace } from "../../agents/openclawImport";
+import type { RuntimeEngine } from "../../contracts/runtime";
+import type { CronService } from "../../cron/service";
+import type { HeartbeatRuntimeService } from "../../heartbeat/runtimeService";
+import { syncMemoryIndex } from "../../memory/service";
+import type { RunService } from "../../run/service";
+import type { RouteTable } from "../router";
+import type { RuntimeEventStream } from "../sse";
+import { createAgentRoutes } from "./agentRoutes";
+import { createBackgroundRoutes } from "./backgroundRoutes";
+import { createChatRoutes } from "./chatRoutes";
+import { createConfigRoutes } from "./configRoutes";
+import { createCronRoutes } from "./cronRoutes";
+import { createDashboardRoutes } from "./dashboardRoutes";
+import { createEventRoutes } from "./eventRoutes";
+import { createHeartbeatRoutes } from "./heartbeatRoutes";
+import { createMcpRoutes } from "./mcpRoutes";
+import { createMemoryRoutes } from "./memoryRoutes";
+import { createRunRoutes } from "./runRoutes";
+import { createRuntimeRoutes } from "./runtimeRoutes";
+import { createSkillRoutes } from "./skillRoutes";
+import { createUiRoutes } from "./uiRoutes";
+import { createUsageRoutes } from "./usageRoutes";
+
+async function importOpenclaw(req: Request) {
+  const schema = z.object({
+    source: z.discriminatedUnion("mode", [
+      z.object({
+        mode: z.literal("local"),
+        path: z.string().min(1),
+      }),
+      z.object({
+        mode: z.literal("git"),
+        url: z.string().min(1),
+        ref: z.string().optional(),
+      }),
+    ]),
+    targetDirectory: z.string().optional(),
+  });
+
+  const parsed = schema.safeParse(await req.json());
+  if (!parsed.success) {
+    return Response.json({ error: "Invalid import request", issues: parsed.error.issues }, { status: 400 });
+  }
+
+  try {
+    const migration = await migrateOpenclawWorkspace(parsed.data);
+    let memorySync: { attempted: boolean; completed: boolean; error?: string | null } = {
+      attempted: false,
+      completed: false,
+      error: null,
+    };
+    try {
+      await syncMemoryIndex();
+      memorySync = { attempted: true, completed: true, error: null };
+    } catch (error) {
+      memorySync = {
+        attempted: true,
+        completed: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+    return Response.json({ migration, memorySync });
+  } catch (error) {
+    return Response.json(
+      { error: error instanceof Error ? error.message : "Failed to import OpenClaw workspace files" },
+      { status: 422 },
+    );
+  }
+}
+
+export function createApiRoutes(input: {
+  runtime: RuntimeEngine;
+  cronService: CronService;
+  heartbeatService: HeartbeatRuntimeService;
+  eventStream: RuntimeEventStream;
+  runService: RunService;
+}): RouteTable {
+  return {
+    "/api/mockingbird/runtime/import-openclaw": {
+      POST: (req: Request) => importOpenclaw(req),
+    },
+    ...createRuntimeRoutes({ cronService: input.cronService }),
+    ...createHeartbeatRoutes(input.heartbeatService),
+    ...createChatRoutes(input.runtime),
+    ...createRunRoutes(input.runService),
+    ...createBackgroundRoutes(input.runtime),
+    ...createDashboardRoutes(input.runtime),
+    ...createConfigRoutes(input.eventStream),
+    ...createUiRoutes(input.runtime),
+    ...createUsageRoutes(),
+    ...createEventRoutes(input.eventStream),
+    ...createAgentRoutes(),
+    ...createMcpRoutes(),
+    ...createSkillRoutes(),
+    ...createCronRoutes(input.cronService),
+    ...createMemoryRoutes(),
+  };
+}

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

@@ -0,0 +1,213 @@
+import type { Config as OpencodeConfig } from "@opencode-ai/sdk/client";
+
+import { configuredMcpServerSchema } from "../../config/schema";
+import { getConfigSnapshot } from "../../config/service";
+import {
+  createOpencodeClientFromConnection,
+  createOpencodeV2ClientFromConnection,
+  unwrapSdkData,
+} from "../../opencode/client";
+
+function getConnectionConfig() {
+  const snapshot = getConfigSnapshot();
+  return {
+    baseUrl: snapshot.config.runtime.opencode.baseUrl,
+    directory: snapshot.config.workspace.pinnedDirectory,
+    timeoutMs: snapshot.config.runtime.opencode.timeoutMs,
+  };
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+async function loadOpencodeConfig() {
+  const connection = getConnectionConfig();
+  const client = createOpencodeClientFromConnection(connection);
+  return unwrapSdkData<OpencodeConfig>(
+    await client.config.get({
+      responseStyle: "data",
+      throwOnError: true,
+      signal: AbortSignal.timeout(connection.timeoutMs),
+    }),
+  );
+}
+
+async function persistMcpServers(servers: Array<ReturnType<typeof configuredMcpServerSchema.parse>>) {
+  const connection = getConnectionConfig();
+  const client = createOpencodeClientFromConnection(connection);
+  const current = await loadOpencodeConfig();
+  const nextMcp = Object.fromEntries(
+    servers.map(server => [
+      server.id,
+      server.type === "remote"
+        ? {
+            type: "remote",
+            url: server.url,
+            enabled: server.enabled,
+            headers: server.headers,
+            ...(server.oauth === "off" ? { oauth: false } : {}),
+            ...(typeof server.timeoutMs === "number" ? { timeout: server.timeoutMs } : {}),
+          }
+        : {
+            type: "local",
+            command: server.command,
+            enabled: server.enabled,
+            environment: server.environment,
+            ...(typeof server.timeoutMs === "number" ? { timeout: server.timeoutMs } : {}),
+          },
+    ]),
+  );
+  const nextConfig = {
+    ...(current as Record<string, unknown>),
+    mcp: nextMcp,
+  } as OpencodeConfig;
+
+  await client.config.update({
+    body: nextConfig,
+    responseStyle: "data",
+    throwOnError: true,
+    signal: AbortSignal.timeout(connection.timeoutMs),
+  });
+  await client.instance.dispose({
+    responseStyle: "data",
+    throwOnError: false,
+    signal: AbortSignal.timeout(connection.timeoutMs),
+  }).catch(() => undefined);
+}
+
+function normalizeServers(config: OpencodeConfig) {
+  const raw = (config as Record<string, unknown>).mcp;
+  if (!isPlainObject(raw)) return [];
+  const servers = [];
+  for (const [id, value] of Object.entries(raw)) {
+    if (!isPlainObject(value) || typeof value.type !== "string") continue;
+    const candidate = configuredMcpServerSchema.safeParse({ id, ...value });
+    if (candidate.success) {
+      servers.push(candidate.data);
+    }
+  }
+  return servers.sort((left, right) => left.id.localeCompare(right.id));
+}
+
+async function loadStatuses() {
+  const connection = getConnectionConfig();
+  const client = createOpencodeV2ClientFromConnection(connection);
+  return unwrapSdkData<Record<string, unknown>>(
+    await client.mcp.status(undefined, {
+      responseStyle: "data",
+      throwOnError: true,
+      signal: AbortSignal.timeout(connection.timeoutMs),
+    }),
+  );
+}
+
+export function createMcpRoutes() {
+  return {
+    "/api/mockingbird/mcp": {
+      GET: async () => {
+        try {
+          const config = await loadOpencodeConfig();
+          const servers = normalizeServers(config);
+          const status = await loadStatuses().catch(() => ({}));
+          return Response.json({ servers, status });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to load MCP config";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+      PUT: async (req: Request) => {
+        const body = (await req.json()) as { servers?: unknown };
+        if (!Array.isArray(body.servers)) {
+          return Response.json({ error: "servers must be an array" }, { status: 400 });
+        }
+        const parsedServers = [];
+        for (const server of body.servers) {
+          const parsed = configuredMcpServerSchema.safeParse(server);
+          if (!parsed.success) {
+            return Response.json(
+              { error: parsed.error.issues[0]?.message ?? "Invalid MCP server definition" },
+              { status: 400 },
+            );
+          }
+          parsedServers.push(parsed.data);
+        }
+        await persistMcpServers(parsedServers);
+        const config = await loadOpencodeConfig();
+        return Response.json({ servers: normalizeServers(config), status: await loadStatuses().catch(() => ({})) });
+      },
+    },
+
+    "/api/mockingbird/mcp/:id/connect": {
+      POST: async (req: Request & { params: { id: string } }) => {
+        const connection = getConnectionConfig();
+        const client = createOpencodeV2ClientFromConnection(connection);
+        const connected = unwrapSdkData<boolean>(
+          await client.mcp.connect(
+            { name: req.params.id },
+            {
+              responseStyle: "data",
+              throwOnError: true,
+              signal: AbortSignal.timeout(connection.timeoutMs),
+            },
+          ),
+        );
+        return Response.json({ connected, status: await loadStatuses() });
+      },
+    },
+
+    "/api/mockingbird/mcp/:id/disconnect": {
+      POST: async (req: Request & { params: { id: string } }) => {
+        const connection = getConnectionConfig();
+        const client = createOpencodeV2ClientFromConnection(connection);
+        const disconnected = unwrapSdkData<boolean>(
+          await client.mcp.disconnect(
+            { name: req.params.id },
+            {
+              responseStyle: "data",
+              throwOnError: true,
+              signal: AbortSignal.timeout(connection.timeoutMs),
+            },
+          ),
+        );
+        return Response.json({ disconnected, status: await loadStatuses() });
+      },
+    },
+
+    "/api/mockingbird/mcp/:id/auth/start": {
+      POST: async (req: Request & { params: { id: string } }) => {
+        const connection = getConnectionConfig();
+        const client = createOpencodeV2ClientFromConnection(connection);
+        const authorization = unwrapSdkData<{ authorizationUrl: string }>(
+          await client.mcp.auth.start(
+            { name: req.params.id },
+            {
+              responseStyle: "data",
+              throwOnError: true,
+              signal: AbortSignal.timeout(connection.timeoutMs),
+            },
+          ),
+        );
+        return Response.json(authorization);
+      },
+    },
+
+    "/api/mockingbird/mcp/:id/auth/remove": {
+      POST: async (req: Request & { params: { id: string } }) => {
+        const connection = getConnectionConfig();
+        const client = createOpencodeV2ClientFromConnection(connection);
+        const result = unwrapSdkData<{ success: true }>(
+          await client.mcp.auth.remove(
+            { name: req.params.id },
+            {
+              responseStyle: "data",
+              throwOnError: true,
+              signal: AbortSignal.timeout(connection.timeoutMs),
+            },
+          ),
+        );
+        return Response.json(result);
+      },
+    },
+  };
+}

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

@@ -0,0 +1,154 @@
+import {
+  getMemoryStatus,
+  listMemoryWriteEvents,
+  readMemoryFileSlice,
+  rememberMemory,
+  searchMemoryDetailed,
+  searchMemory,
+  syncMemoryIndex,
+  validateMemoryRememberInput,
+} from "../../memory/service";
+import { parseMemoryRememberBody } from "../parsers";
+
+export function createMemoryRoutes() {
+  return {
+    "/api/mockingbird/memory/status": {
+      GET: async () => {
+        try {
+          return Response.json({ status: await getMemoryStatus() });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to load memory status";
+          return Response.json({ error: message }, { status: 500 });
+        }
+      },
+    },
+
+    "/api/mockingbird/memory/activity": {
+      GET: async (req: Request) => {
+        try {
+          const url = new URL(req.url);
+          const requestedLimit = Number(url.searchParams.get("limit") ?? "20");
+          const events = await listMemoryWriteEvents(requestedLimit);
+          return Response.json({ events });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Failed to load memory activity";
+          return Response.json({ error: message }, { status: 500 });
+        }
+      },
+    },
+
+    "/api/mockingbird/memory/sync": {
+      POST: async () => {
+        try {
+          await syncMemoryIndex();
+          return Response.json({ status: await getMemoryStatus() });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Memory sync failed";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+    },
+
+    "/api/mockingbird/memory/reindex": {
+      POST: async () => {
+        try {
+          await syncMemoryIndex({ force: true });
+          return Response.json({ status: await getMemoryStatus() });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Memory reindex failed";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+    },
+
+    "/api/mockingbird/memory/retrieve": {
+      POST: async (req: Request) => {
+        const body = (await req.json()) as { query?: string; maxResults?: number; minScore?: number; debug?: boolean };
+        const query = body.query?.trim();
+        if (!query) {
+          return Response.json({ error: "query is required" }, { status: 400 });
+        }
+        try {
+          const options = {
+            maxResults: typeof body.maxResults === "number" ? body.maxResults : undefined,
+            minScore: typeof body.minScore === "number" ? body.minScore : undefined,
+          };
+          if (body.debug) {
+            const detailed = await searchMemoryDetailed(query, options);
+            return Response.json({ results: detailed.results, debug: detailed.debug });
+          }
+          const results = await searchMemory(query, options);
+          return Response.json({ results, debug: undefined });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Memory retrieve failed";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+    },
+
+    "/api/mockingbird/memory/read": {
+      POST: async (req: Request) => {
+        const body = (await req.json()) as { path?: string; from?: number; lines?: number };
+        const relPath = body.path?.trim();
+        if (!relPath) {
+          return Response.json({ error: "path is required" }, { status: 400 });
+        }
+        try {
+          const result = await readMemoryFileSlice({
+            relPath,
+            from: typeof body.from === "number" ? body.from : undefined,
+            lines: typeof body.lines === "number" ? body.lines : undefined,
+          });
+          return Response.json(result);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Memory read failed";
+          return Response.json({ error: message }, { status: 400 });
+        }
+      },
+    },
+
+    "/api/mockingbird/memory/remember": {
+      POST: async (req: Request) => {
+        const body = parseMemoryRememberBody(await req.json());
+        if (!body) {
+          return Response.json(
+            {
+              error:
+                "Invalid payload. Expected { source?, content, entities?, confidence?, supersedes?, sessionId?, topic?, ttl? }",
+            },
+            { status: 400 },
+          );
+        }
+        try {
+          const result = await rememberMemory(body);
+          return Response.json(result, { status: result.accepted ? 201 : 422 });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Memory write failed";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+    },
+
+    "/api/mockingbird/memory/remember/validate": {
+      POST: async (req: Request) => {
+        const body = parseMemoryRememberBody(await req.json());
+        if (!body) {
+          return Response.json(
+            {
+              error:
+                "Invalid payload. Expected { source?, content, entities?, confidence?, supersedes?, sessionId?, topic?, ttl? }",
+            },
+            { status: 400 },
+          );
+        }
+        try {
+          const validation = await validateMemoryRememberInput(body);
+          return Response.json({ validation });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "Memory validation failed";
+          return Response.json({ error: message }, { status: 502 });
+        }
+      },
+    },
+  };
+}