agent-mockingbird 0.0.1

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

@@ -0,0 +1,161 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import type { createUiRoutes as CreateUiRoutesType } from "./uiRoutes";
+import type * as RepositoryModuleType from "../../db/repository";
+
+const testRoot = mkdtempSync(path.join(tmpdir(), "agent-mockingbird-ui-routes-test-"));
+const testDbPath = path.join(testRoot, "agent-mockingbird.ui-routes.test.db");
+const testConfigPath = path.join(testRoot, "agent-mockingbird.ui-routes.config.json");
+const testWorkspacePath = path.join(testRoot, "workspace");
+
+process.env.NODE_ENV = "test";
+process.env.AGENT_MOCKINGBIRD_DB_PATH = testDbPath;
+process.env.AGENT_MOCKINGBIRD_CONFIG_PATH = testConfigPath;
+process.env.AGENT_MOCKINGBIRD_MEMORY_WORKSPACE_DIR = testWorkspacePath;
+process.env.AGENT_MOCKINGBIRD_MEMORY_EMBED_PROVIDER = "none";
+
+interface RuntimeStub {
+  syncSessionMessages: (sessionId: string) => Promise<void>;
+  listBackgroundRuns: (input?: { parentSessionId?: string; limit?: number; inFlightOnly?: boolean }) => Promise<
+    Array<{
+      runId: string;
+      parentSessionId: string;
+      parentExternalSessionId: string;
+      childExternalSessionId: string;
+      childSessionId: string | null;
+      status: string;
+      startedAt: string | null;
+      completedAt: string | null;
+      error: string | null;
+    }>
+  >;
+}
+
+type CreateUiRoutesFn = typeof CreateUiRoutesType;
+type RepositoryModule = typeof RepositoryModuleType;
+
+let createUiRoutes: CreateUiRoutesFn;
+let repository: RepositoryModule;
+
+beforeAll(async () => {
+  await import("../../db/migrate");
+  const uiRoutesModule = await import("./uiRoutes");
+  const repositoryModule = await import("../../db/repository");
+  createUiRoutes = uiRoutesModule.createUiRoutes;
+  repository = repositoryModule;
+});
+
+beforeEach(() => {
+  repository.resetDatabaseToDefaults();
+});
+
+afterAll(() => {
+  rmSync(testRoot, { recursive: true, force: true });
+});
+
+function buildRuntimeStub(): RuntimeStub {
+  return {
+    syncSessionMessages: async () => undefined,
+    listBackgroundRuns: async () => [],
+  };
+}
+
+describe("uiRoutes contracts", () => {
+  test("GET /api/ui/session-screen/bootstrap returns screen bootstrap payload", async () => {
+    const session = repository.createSession({ title: "UI Routes Test" });
+    repository.appendChatExchange({
+      sessionId: session.id,
+      userContent: "hello",
+      assistantContent: "world",
+      source: "api",
+      usage: {
+        requestCountDelta: 1,
+        inputTokensDelta: 5,
+        outputTokensDelta: 8,
+        estimatedCostUsdDelta: 0.001,
+      },
+    });
+
+    const routes = createUiRoutes(buildRuntimeStub() as never);
+    const handler = routes["/api/ui/session-screen/bootstrap"]?.GET;
+    expect(handler).toBeDefined();
+
+    const response = await handler!(new Request(`http://localhost/api/ui/session-screen/bootstrap?sessionId=${encodeURIComponent(session.id)}`));
+    expect(response.status).toBe(200);
+
+    const payload = await response.json() as Record<string, unknown>;
+    expect(Array.isArray(payload.sessions)).toBe(true);
+    expect(payload.activeSessionId).toBe(session.id);
+    expect(Array.isArray(payload.messages)).toBe(true);
+    expect(typeof payload.usage).toBe("object");
+    expect(payload.usage).not.toBeNull();
+    expect(typeof payload.heartbeat).toBe("object");
+    expect(payload.heartbeat).not.toBeNull();
+    expect(typeof payload.featureFlags).toBe("object");
+    expect(payload.featureFlags).not.toBeNull();
+  });
+
+  test("GET /api/ui/sessions/:id/context returns context payload", async () => {
+    const session = repository.createSession({ title: "Context Session" });
+    repository.appendChatExchange({
+      sessionId: session.id,
+      userContent: "show me context",
+      assistantContent: "sure",
+      source: "api",
+      usage: {
+        requestCountDelta: 1,
+        inputTokensDelta: 9,
+        outputTokensDelta: 12,
+        estimatedCostUsdDelta: 0.0015,
+      },
+    });
+
+    const routes = createUiRoutes(buildRuntimeStub() as never);
+    const handler = routes["/api/ui/sessions/:id/context"]?.GET;
+    expect(handler).toBeDefined();
+
+    const request = Object.assign(new Request("http://localhost/api/ui/sessions/id/context"), {
+      params: { id: session.id },
+    });
+    const response = await handler!(request as never);
+    expect(response.status).toBe(200);
+
+    const payload = await response.json() as Record<string, unknown>;
+    expect(typeof payload.session).toBe("object");
+    expect(payload.session).not.toBeNull();
+    expect(typeof payload.metrics).toBe("object");
+    expect(payload.metrics).not.toBeNull();
+    expect(typeof payload.contextBreakdown).toBe("object");
+    expect(payload.contextBreakdown).not.toBeNull();
+
+    const metrics = payload.metrics as { totalMessages?: number };
+    expect(typeof metrics.totalMessages).toBe("number");
+    expect((metrics.totalMessages ?? 0) > 0).toBe(true);
+  });
+
+  test("GET /api/ui/sessions/:id/review returns placeholder review contract", async () => {
+    const session = repository.createSession({ title: "Review Placeholder" });
+    const routes = createUiRoutes(buildRuntimeStub() as never);
+    const handler = routes["/api/ui/sessions/:id/review"]?.GET;
+    expect(handler).toBeDefined();
+
+    const request = Object.assign(new Request("http://localhost/api/ui/sessions/id/review"), {
+      params: { id: session.id },
+    });
+    const response = await handler!(request as never);
+    expect(response.status).toBe(200);
+
+    const payload = await response.json() as {
+      enabled?: boolean;
+      reason?: string;
+      sessionId?: string;
+    };
+
+    expect(payload.enabled).toBe(false);
+    expect(payload.reason).toBe("review_not_yet_mapped");
+    expect(payload.sessionId).toBe(session.id);
+  });
+});

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

@@ -0,0 +1,177 @@
+import { buildWorkspaceBootstrapPromptContext } from "../../agents/bootstrapContext";
+import type { RuntimeEngine } from "../../contracts/runtime";
+import {
+  getHeartbeatSnapshot,
+  getSessionById,
+  getUsageSnapshot,
+  listMessagesForSession,
+  listSessions,
+} from "../../db/repository";
+import { isActiveHeartbeatSession } from "../../heartbeat/state";
+import { listOpencodeModelOptions } from "../../opencode/models";
+import { listPendingPrompts } from "../../prompts/service";
+
+function clampPercent(value: number): number {
+  if (!Number.isFinite(value)) return 0;
+  return Math.max(0, Math.min(100, value));
+}
+
+function estimateContextBreakdown(messages: ReturnType<typeof listMessagesForSession>) {
+  const userChars = messages.filter(msg => msg.role === "user").reduce((sum, msg) => sum + msg.content.length, 0);
+  const assistantChars = messages.filter(msg => msg.role === "assistant").reduce((sum, msg) => sum + msg.content.length, 0);
+  const toolCount = messages
+    .filter(msg => msg.role === "assistant")
+    .flatMap(msg => msg.parts ?? [])
+    .filter(part => part.type === "tool_call").length;
+  const thinkingCount = messages
+    .filter(msg => msg.role === "assistant")
+    .flatMap(msg => msg.parts ?? [])
+    .filter(part => part.type === "thinking").length;
+
+  const weightedUser = userChars;
+  const weightedAssistant = assistantChars;
+  const weightedTools = toolCount * 320;
+  const weightedOther = thinkingCount * 120;
+  const weightedSystem = Math.max(800, Math.floor((weightedUser + weightedAssistant) * 0.06));
+  const total = Math.max(1, weightedUser + weightedAssistant + weightedTools + weightedOther + weightedSystem);
+
+  return {
+    system: clampPercent((weightedSystem / total) * 100),
+    user: clampPercent((weightedUser / total) * 100),
+    assistant: clampPercent((weightedAssistant / total) * 100),
+    tools: clampPercent((weightedTools / total) * 100),
+    other: clampPercent((weightedOther / total) * 100),
+  };
+}
+
+export function createUiRoutes(runtime: RuntimeEngine) {
+  return {
+    "/api/ui/session-screen/bootstrap": {
+      GET: async (req: Request) => {
+        const url = new URL(req.url);
+        const requestedSessionId = url.searchParams.get("sessionId")?.trim() ?? "";
+        const sessions = listSessions().filter(session => !isActiveHeartbeatSession(session.id));
+        const activeSessionId =
+          (requestedSessionId && !isActiveHeartbeatSession(requestedSessionId) ? requestedSessionId : "") ||
+          sessions[0]?.id ||
+          "";
+
+        if (activeSessionId && runtime.syncSessionMessages) {
+          try {
+            await runtime.syncSessionMessages(activeSessionId);
+          } catch {
+            // Best effort sync only.
+          }
+        }
+
+        const activeSession = activeSessionId ? getSessionById(activeSessionId) : null;
+        const messages = activeSessionId ? listMessagesForSession(activeSessionId) : [];
+        const usage = getUsageSnapshot();
+        const heartbeat = getHeartbeatSnapshot();
+        const modelsPayload = await listOpencodeModelOptions().catch(() => []);
+        const pendingPrompts = await listPendingPrompts().catch(() => ({
+          pendingPermissions: [],
+          pendingQuestions: [],
+        }));
+        const backgroundRuns = runtime.listBackgroundRuns
+          ? await runtime.listBackgroundRuns({ parentSessionId: activeSessionId || undefined, limit: 250 }).catch(() => [])
+          : [];
+        const workspaceBootstrap = buildWorkspaceBootstrapPromptContext();
+
+        return Response.json({
+          sessions,
+          activeSessionId,
+          activeSession,
+          messages,
+          usage,
+          heartbeat,
+          models: modelsPayload,
+          pendingPermissions: pendingPrompts.pendingPermissions,
+          pendingQuestions: pendingPrompts.pendingQuestions,
+          backgroundRuns,
+          workspaceBootstrap: {
+            mode: workspaceBootstrap.mode,
+            identity: workspaceBootstrap.identity,
+            files: workspaceBootstrap.files.map(file => ({
+              name: file.name,
+              missing: file.missing,
+              truncated: file.truncated,
+            })),
+          },
+          featureFlags: {
+            reviewEnabled: false,
+          },
+        });
+      },
+    },
+
+    "/api/ui/sessions/:id/context": {
+      GET: async (req: Request & { params: { id: string } }) => {
+        const sessionId = req.params.id;
+        const session = getSessionById(sessionId);
+        if (!session) {
+          return Response.json({ error: "Unknown session" }, { status: 404 });
+        }
+        if (runtime.syncSessionMessages) {
+          try {
+            await runtime.syncSessionMessages(sessionId);
+          } catch {
+            // Best effort sync only.
+          }
+        }
+
+        const messages = listMessagesForSession(sessionId);
+        const usage = getUsageSnapshot();
+        const bootstrap = buildWorkspaceBootstrapPromptContext();
+        const userMessages = messages.filter(msg => msg.role === "user");
+        const assistantMessages = messages.filter(msg => msg.role === "assistant");
+        const breakdown = estimateContextBreakdown(messages);
+
+        return Response.json({
+          session: {
+            id: session.id,
+            title: session.title,
+            model: session.model,
+            status: session.status,
+            createdAt: session.lastActiveAt,
+            lastActiveAt: session.lastActiveAt,
+            messageCount: session.messageCount,
+          },
+          metrics: {
+            userMessages: userMessages.length,
+            assistantMessages: assistantMessages.length,
+            totalMessages: messages.length,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            totalTokens: usage.inputTokens + usage.outputTokens,
+            estimatedCostUsd: usage.estimatedCostUsd,
+          },
+          contextBreakdown: breakdown,
+          bootstrap: {
+            mode: bootstrap.mode,
+            files: bootstrap.files.map(file => ({
+              name: file.name,
+              path: file.path,
+              missing: file.missing,
+              truncated: file.truncated,
+            })),
+          },
+        });
+      },
+    },
+
+    "/api/ui/sessions/:id/review": {
+      GET: (req: Request & { params: { id: string } }) => {
+        const session = getSessionById(req.params.id);
+        if (!session) {
+          return Response.json({ error: "Unknown session" }, { status: 404 });
+        }
+        return Response.json({
+          enabled: false,
+          reason: "review_not_yet_mapped",
+          sessionId: session.id,
+        });
+      },
+    },
+  };
+}

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

@@ -0,0 +1,104 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import type { createUsageRoutes as CreateUsageRoutesType } from "./usageRoutes";
+import type * as RepositoryModuleType from "../../db/repository";
+
+const testRoot = mkdtempSync(path.join(tmpdir(), "agent-mockingbird-usage-routes-test-"));
+const testDbPath = path.join(testRoot, "agent-mockingbird.usage-routes.test.db");
+const testConfigPath = path.join(testRoot, "agent-mockingbird.usage-routes.config.json");
+const testWorkspacePath = path.join(testRoot, "workspace");
+
+process.env.NODE_ENV = "test";
+process.env.AGENT_MOCKINGBIRD_DB_PATH = testDbPath;
+process.env.AGENT_MOCKINGBIRD_CONFIG_PATH = testConfigPath;
+process.env.AGENT_MOCKINGBIRD_MEMORY_WORKSPACE_DIR = testWorkspacePath;
+process.env.AGENT_MOCKINGBIRD_MEMORY_EMBED_PROVIDER = "none";
+
+type CreateUsageRoutesFn = typeof CreateUsageRoutesType;
+type RepositoryModule = typeof RepositoryModuleType;
+
+let createUsageRoutes: CreateUsageRoutesFn;
+let repository: RepositoryModule;
+
+beforeAll(async () => {
+  await import("../../db/migrate");
+  ({ createUsageRoutes } = await import("./usageRoutes"));
+  repository = await import("../../db/repository");
+});
+
+beforeEach(() => {
+  repository.resetDatabaseToDefaults();
+});
+
+afterAll(() => {
+  rmSync(testRoot, { recursive: true, force: true });
+});
+
+describe("usage routes", () => {
+  test("GET /api/usage/dashboard returns grouped range-filtered usage data", async () => {
+    const session = repository.createSession({
+      title: "Usage Route Session",
+      model: "anthropic/claude-sonnet-4.5",
+    });
+    const createdAt = Date.now();
+    repository.recordUsageDelta({
+      sessionId: session.id,
+      requestCountDelta: 1,
+      inputTokensDelta: 12,
+      outputTokensDelta: 34,
+      estimatedCostUsdDelta: 0.1234,
+      source: "runtime",
+      createdAt,
+    });
+
+    const routes = createUsageRoutes();
+    const handler = routes["/api/usage/dashboard"]?.GET;
+    expect(handler).toBeDefined();
+
+    const response = await handler!(new Request(`http://localhost/api/usage/dashboard?startAt=${createdAt - 1}&endAtExclusive=${createdAt + 1}`));
+    expect(response.status).toBe(200);
+
+    const payload = await response.json() as {
+      rangeStartAt: string | null;
+      rangeEndAtExclusive: string | null;
+      totals: { totalTokens: number };
+      providers: Array<{ providerId: string }>;
+      models: Array<{ providerId: string; modelId: string }>;
+      forwardOnlyBreakdown: boolean;
+    };
+
+    expect(payload.rangeStartAt).not.toBeNull();
+    expect(payload.rangeEndAtExclusive).not.toBeNull();
+    expect(payload.totals.totalTokens).toBe(46);
+    expect(payload.providers).toHaveLength(1);
+    expect(payload.providers[0]).toMatchObject({ providerId: "anthropic" });
+    expect(payload.models).toHaveLength(1);
+    expect(payload.models[0]).toMatchObject({ providerId: "anthropic", modelId: "claude-sonnet-4.5" });
+    expect(payload.forwardOnlyBreakdown).toBe(true);
+  });
+
+  test("GET /usage returns standalone usage html", async () => {
+    const routes = createUsageRoutes();
+    const handler = routes["/usage"]?.GET;
+    expect(handler).toBeDefined();
+
+    const response = await handler!();
+    expect(response.status).toBe(200);
+    expect(response.headers.get("content-type")).toContain("text/html");
+
+    const html = await response.text();
+    expect(html).toContain("<title>Usage</title>");
+    expect(html).toContain("/api/usage/dashboard");
+    expect(html).toContain("Back to app");
+    expect(html).toContain("window.history.back()");
+    expect(html).toContain("window.location.origin");
+    expect(html).toContain("All time");
+    expect(html).toContain("Apply range");
+    expect(html).toContain("Month to date");
+    expect(html).toContain("usage-start-date");
+    expect(html).toContain("usage-end-date");
+  });
+});