agent-mockingbird 0.0.1

package/apps/server/src/backend/db/schema.ts

@@ -0,0 +1,113 @@
+import { sql } from "drizzle-orm";
+import { index, integer, primaryKey, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+const nowMs = sql`(strftime('%s', 'now') * 1000)`;
+
+export const sessions = sqliteTable(
+  "sessions",
+  {
+    id: text("id").primaryKey(),
+    title: text("title").notNull(),
+    model: text("model").notNull(),
+    status: text("status", { enum: ["active", "idle"] }).notNull().default("idle"),
+    messageCount: integer("message_count").notNull().default(0),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(nowMs),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().default(nowMs),
+    lastActiveAt: integer("last_active_at", { mode: "timestamp_ms" }).notNull().default(nowMs),
+  },
+  table => [index("sessions_last_active_idx").on(table.lastActiveAt)],
+);
+
+export const messages = sqliteTable(
+  "messages",
+  {
+    id: text("id").primaryKey(),
+    sessionId: text("session_id")
+      .notNull()
+      .references(() => sessions.id, { onDelete: "cascade" }),
+    role: text("role", { enum: ["user", "assistant"] }).notNull(),
+    content: text("content").notNull(),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(nowMs),
+  },
+  table => [index("messages_session_created_idx").on(table.sessionId, table.createdAt)],
+);
+
+export const usageEvents = sqliteTable(
+  "usage_events",
+  {
+    id: text("id").primaryKey(),
+    sessionId: text("session_id").references(() => sessions.id, { onDelete: "set null" }),
+    providerId: text("provider_id"),
+    modelId: text("model_id"),
+    requestCountDelta: integer("request_count_delta").notNull().default(0),
+    inputTokensDelta: integer("input_tokens_delta").notNull().default(0),
+    outputTokensDelta: integer("output_tokens_delta").notNull().default(0),
+    estimatedCostUsdDelta: integer("estimated_cost_usd_delta_micros").notNull().default(0),
+    source: text("source", { enum: ["api", "runtime", "scheduler", "system"] }).notNull().default("system"),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(nowMs),
+  },
+  table => [
+    index("usage_events_created_idx").on(table.createdAt),
+    index("usage_events_provider_created_idx").on(table.providerId, table.createdAt),
+    index("usage_events_provider_model_created_idx").on(table.providerId, table.modelId, table.createdAt),
+  ],
+);
+
+export const heartbeatEvents = sqliteTable(
+  "heartbeat_events",
+  {
+    id: text("id").primaryKey(),
+    online: integer("online", { mode: "boolean" }).notNull().default(true),
+    source: text("source", { enum: ["api", "runtime", "scheduler", "system"] }).notNull().default("system"),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(nowMs),
+  },
+  table => [index("heartbeat_events_created_idx").on(table.createdAt)],
+);
+
+export const runtimeConfig = sqliteTable("runtime_config", {
+  key: text("key").primaryKey(),
+  valueJson: text("value_json").notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().default(nowMs),
+});
+
+export const runtimeSessionBindings = sqliteTable(
+  "runtime_session_bindings",
+  {
+    runtime: text("runtime").notNull(),
+    sessionId: text("session_id").notNull(),
+    externalSessionId: text("external_session_id").notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().default(nowMs),
+  },
+  table => [
+    primaryKey({ columns: [table.runtime, table.sessionId] }),
+    index("runtime_session_bindings_external_idx").on(table.runtime, table.externalSessionId),
+    index("runtime_session_bindings_updated_idx").on(table.updatedAt),
+  ],
+);
+
+export const backgroundRuns = sqliteTable(
+  "background_runs",
+  {
+    id: text("id").primaryKey(),
+    runtime: text("runtime").notNull(),
+    parentSessionId: text("parent_session_id")
+      .notNull()
+      .references(() => sessions.id, { onDelete: "cascade" }),
+    parentExternalSessionId: text("parent_external_session_id").notNull(),
+    childExternalSessionId: text("child_external_session_id").notNull(),
+    requestedBy: text("requested_by").notNull().default("system"),
+    prompt: text("prompt").notNull().default(""),
+    status: text("status").notNull().default("created"),
+    resultSummary: text("result_summary"),
+    error: text("error"),
+    createdAt: integer("created_at", { mode: "timestamp_ms" }).notNull().default(nowMs),
+    updatedAt: integer("updated_at", { mode: "timestamp_ms" }).notNull().default(nowMs),
+    startedAt: integer("started_at", { mode: "timestamp_ms" }),
+    completedAt: integer("completed_at", { mode: "timestamp_ms" }),
+  },
+  table => [
+    index("background_runs_child_external_idx").on(table.runtime, table.childExternalSessionId),
+    index("background_runs_parent_created_idx").on(table.parentSessionId, table.createdAt),
+    index("background_runs_status_updated_idx").on(table.status, table.updatedAt),
+  ],
+);

package/apps/server/src/backend/db/usageDashboard.test.ts

@@ -0,0 +1,102 @@
+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 * as RepositoryModuleType from "./repository";
+
+const testRoot = mkdtempSync(path.join(tmpdir(), "agent-mockingbird-usage-db-test-"));
+const testDbPath = path.join(testRoot, "agent-mockingbird.usage-dashboard.test.db");
+const testConfigPath = path.join(testRoot, "agent-mockingbird.usage-dashboard.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 RepositoryModule = typeof RepositoryModuleType;
+
+let repository: RepositoryModule;
+
+beforeAll(async () => {
+  await import("./migrate");
+  repository = await import("./repository");
+});
+
+beforeEach(() => {
+  repository.resetDatabaseToDefaults();
+});
+
+afterAll(() => {
+  rmSync(testRoot, { recursive: true, force: true });
+});
+
+describe("usage dashboard repository", () => {
+  test("groups attributed usage by provider and model for the selected date range", () => {
+    const now = Date.now();
+    const session = repository.createSession({
+      title: "Usage Session",
+      model: "anthropic/claude-sonnet-4.5",
+    });
+
+    repository.recordUsageDelta({
+      sessionId: session.id,
+      requestCountDelta: 1,
+      inputTokensDelta: 120,
+      outputTokensDelta: 80,
+      estimatedCostUsdDelta: 0.42,
+      source: "runtime",
+      createdAt: now - 2 * 60 * 60 * 1000,
+    });
+    repository.recordUsageDelta({
+      requestCountDelta: 1,
+      inputTokensDelta: 40,
+      outputTokensDelta: 10,
+      estimatedCostUsdDelta: 0.08,
+      source: "system",
+      createdAt: now - 60 * 60 * 1000,
+    });
+    repository.recordUsageDelta({
+      providerId: "openai",
+      modelId: "gpt-5.4",
+      requestCountDelta: 1,
+      inputTokensDelta: 500,
+      outputTokensDelta: 400,
+      estimatedCostUsdDelta: 1.5,
+      source: "runtime",
+      createdAt: now - 10 * 24 * 60 * 60 * 1000,
+    });
+
+    const recentRange = repository.getUsageDashboardSnapshot({
+      startAt: now - 24 * 60 * 60 * 1000,
+      endAtExclusive: now + 1,
+    });
+    expect(recentRange.totals.requestCount).toBe(2);
+    expect(recentRange.totals.totalTokens).toBe(250);
+    expect(recentRange.unattributedTotals.totalTokens).toBe(50);
+    expect(recentRange.providers).toHaveLength(1);
+    expect(recentRange.providers[0]).toMatchObject({
+      providerId: "anthropic",
+      totalTokens: 200,
+    });
+    expect(recentRange.models).toHaveLength(1);
+    expect(recentRange.models[0]).toMatchObject({
+      providerId: "anthropic",
+      modelId: "claude-sonnet-4.5",
+      totalTokens: 200,
+    });
+
+    const fullRange = repository.getUsageDashboardSnapshot({
+      startAt: now - 30 * 24 * 60 * 60 * 1000,
+      endAtExclusive: now + 1,
+    });
+    expect(fullRange.totals.requestCount).toBe(3);
+    expect(fullRange.providers.map(row => row.providerId)).toEqual(["openai", "anthropic"]);
+    expect(fullRange.models.map(row => `${row.providerId}/${row.modelId}`)).toEqual([
+      "openai/gpt-5.4",
+      "anthropic/claude-sonnet-4.5",
+    ]);
+  });
+});

package/apps/server/src/backend/db/wipe.ts

@@ -0,0 +1,13 @@
+import { resolvedDbPath } from "./client";
+import { resetDatabaseToDefaults } from "./repository";
+
+const bootstrap = resetDatabaseToDefaults();
+
+console.log("Database reset complete.");
+console.log(`Target database: ${resolvedDbPath}`);
+console.log(
+  `Sessions: ${bootstrap.sessions.map(session => `${session.id} (${session.title})`).join(", ") || "none"}`,
+);
+console.log(`Skills: ${bootstrap.skills.length}`);
+console.log(`MCP servers: ${bootstrap.mcps.length}`);
+console.log(`Agents: ${bootstrap.agents.length}`);

package/apps/server/src/backend/defaults.ts

@@ -0,0 +1,32 @@
+import type { SpecialistAgent } from "@agent-mockingbird/contracts/dashboard";
+
+import type { AgentTypeDefinition } from "./config/schema";
+
+export const DEFAULT_SKILLS: string[] = [
+  "config-editor",
+  "config-auditor",
+  "runtime-diagnose",
+];
+
+export const DEFAULT_MCPS: string[] = [];
+
+export const DEFAULT_AGENTS: SpecialistAgent[] = [];
+export const DEFAULT_AGENT_TYPES: AgentTypeDefinition[] = [
+  {
+    id: "build",
+    name: "Agent Mockingbird",
+    description: "Default primary agent.",
+    mode: "primary",
+    hidden: false,
+    disable: false,
+    options: {},
+  },
+];
+
+export const DEFAULT_SESSIONS = [
+  {
+    id: "main",
+    title: "Main",
+    model: "claude-sonnet-4.5",
+  },
+];

package/apps/server/src/backend/env.ts

@@ -0,0 +1,48 @@
+import { createEnv } from "@t3-oss/env-core";
+import { z } from "zod";
+
+const envSchema = {
+  NODE_ENV: z.enum(["development", "test", "production"]).default("development"),
+  AGENT_MOCKINGBIRD_DB_PATH: z.string().optional(),
+  AGENT_MOCKINGBIRD_CONFIG_PATH: z.string().optional(),
+  AGENT_MOCKINGBIRD_OPENCODE_BASE_URL: z.string().url().optional(),
+  AGENT_MOCKINGBIRD_OPENCODE_AUTH_HEADER: z.string().optional(),
+  AGENT_MOCKINGBIRD_OPENCODE_USERNAME: z.string().optional(),
+  AGENT_MOCKINGBIRD_OPENCODE_PASSWORD: z.string().optional(),
+  AGENT_MOCKINGBIRD_EXPO_PUSH_API_URL: z.string().url().default("https://exp.host/--/api/v2/push/send"),
+  AGENT_MOCKINGBIRD_CRON_ENABLED: z.coerce.boolean().default(true),
+  AGENT_MOCKINGBIRD_CRON_SCHEDULER_POLL_MS: z.coerce.number().int().min(250).default(1_000),
+  AGENT_MOCKINGBIRD_CRON_WORKER_POLL_MS: z.coerce.number().int().min(250).default(1_000),
+  AGENT_MOCKINGBIRD_CRON_LEASE_MS: z.coerce.number().int().min(1_000).default(30_000),
+  AGENT_MOCKINGBIRD_CRON_MAX_ENQUEUE_PER_JOB_TICK: z.coerce.number().int().min(1).max(1_000).default(25),
+  AGENT_MOCKINGBIRD_MEMORY_ENABLED: z.coerce.boolean().default(true),
+  AGENT_MOCKINGBIRD_MEMORY_WORKSPACE_DIR: z.string().default("./data/workspace"),
+  AGENT_MOCKINGBIRD_MEMORY_EMBED_PROVIDER: z.enum(["ollama", "none"]).default("ollama"),
+  AGENT_MOCKINGBIRD_MEMORY_EMBED_MODEL: z.string().min(1).default("granite-embedding:278m"),
+  AGENT_MOCKINGBIRD_MEMORY_OLLAMA_BASE_URL: z.string().url().default("http://127.0.0.1:11434"),
+  AGENT_MOCKINGBIRD_MEMORY_CHUNK_TOKENS: z.coerce.number().int().positive().default(400),
+  AGENT_MOCKINGBIRD_MEMORY_CHUNK_OVERLAP: z.coerce.number().int().min(0).default(80),
+  AGENT_MOCKINGBIRD_MEMORY_MAX_RESULTS: z.coerce.number().int().positive().default(4),
+  AGENT_MOCKINGBIRD_MEMORY_MIN_SCORE: z.coerce.number().min(0).max(1).default(0.35),
+  AGENT_MOCKINGBIRD_MEMORY_SYNC_COOLDOWN_MS: z.coerce.number().int().min(0).default(10_000),
+  AGENT_MOCKINGBIRD_MEMORY_TOOL_MODE: z.enum(["hybrid", "inject_only", "tool_only"]).default("tool_only"),
+  AGENT_MOCKINGBIRD_MEMORY_INJECTION_DEDUPE_ENABLED: z.coerce.boolean().default(true),
+  AGENT_MOCKINGBIRD_MEMORY_INJECTION_DEDUPE_FALLBACK_RECALL_ONLY: z.coerce.boolean().default(true),
+  AGENT_MOCKINGBIRD_MEMORY_INJECTION_DEDUPE_MAX_TRACKED: z.coerce.number().int().min(32).max(10_000).default(256),
+} satisfies Record<string, z.ZodTypeAny>;
+
+function loadEnv() {
+  return createEnv({
+    server: envSchema,
+    runtimeEnv: process.env,
+    emptyStringAsUndefined: true,
+  });
+}
+
+type AppEnv = ReturnType<typeof loadEnv>;
+
+export const env = new Proxy({} as AppEnv, {
+  get(_target, property) {
+    return loadEnv()[property as keyof AppEnv];
+  },
+});

package/apps/server/src/backend/heartbeat/activeHours.ts

@@ -0,0 +1,45 @@
+import type { HeartbeatConfig } from "./types";
+
+export function isActiveHours(config: HeartbeatConfig): boolean {
+  if (!config.activeHours) return true;
+
+  const { start, end, timezone } = config.activeHours;
+
+  const now = new Date();
+
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone: timezone,
+    hour: "numeric",
+    minute: "numeric",
+    hour12: false,
+  });
+
+  const parts = formatter.formatToParts(now);
+  let hour = 0;
+  let minute = 0;
+
+  for (const part of parts) {
+    if (part.type === "hour") {
+      hour = parseInt(part.value, 10);
+    } else if (part.type === "minute") {
+      minute = parseInt(part.value, 10);
+    }
+  }
+
+  const startParts = start.split(":").map(Number);
+  const endParts = end.split(":").map(Number);
+  const startH = startParts[0] ?? 0;
+  const startM = startParts[1] ?? 0;
+  const endH = endParts[0] ?? 0;
+  const endM = endParts[1] ?? 0;
+
+  const startMinutes = startH * 60 + startM;
+  const endMinutes = endH * 60 + endM;
+  const nowMinutes = hour * 60 + minute;
+
+  if (startMinutes <= endMinutes) {
+    return nowMinutes >= startMinutes && nowMinutes <= endMinutes;
+  } else {
+    return nowMinutes >= startMinutes || nowMinutes <= endMinutes;
+  }
+}

package/apps/server/src/backend/heartbeat/defaultJob.ts

@@ -0,0 +1,88 @@
+import { DEFAULT_HEARTBEAT_PROMPT, parseInterval } from "./service";
+import { ensureCronTables } from "../cron/storage";
+import { sqlite } from "../db/client";
+import { DEFAULT_AGENT_TYPES } from "../defaults";
+
+export const HEARTBEAT_SYSTEM_JOB_ID = "heartbeat-system";
+const HEARTBEAT_SYSTEM_JOB_NAME = "Heartbeat";
+const DEFAULT_HEARTBEAT_INTERVAL = "30m";
+
+function resolveDefaultHeartbeatAgentId() {
+  return (
+    DEFAULT_AGENT_TYPES.find(agent => agent.mode === "primary" && !agent.disable)?.id ??
+    DEFAULT_AGENT_TYPES[0]?.id ??
+    "build"
+  );
+}
+
+function buildDefaultHeartbeatPayload() {
+  return {
+    agentId: resolveDefaultHeartbeatAgentId(),
+  };
+}
+
+export function seedDefaultHeartbeatJob(createdAt: number) {
+  ensureCronTables();
+  sqlite
+    .query(
+      `
+      INSERT INTO cron_job_definitions (
+        id, name, thread_session_id, enabled, schedule_kind, schedule_expr, every_ms, at_iso, timezone,
+        run_mode, handler_key, condition_module_path, condition_description, agent_prompt_template, agent_model_override,
+        max_attempts, retry_backoff_ms, payload_json, last_enqueued_for, created_at, updated_at
+      )
+      VALUES (?1, ?2, NULL, 1, 'every', NULL, ?3, NULL, NULL, 'agent', NULL, NULL, NULL, ?4, NULL, ?5, ?6, ?7, NULL, ?8, ?8)
+      ON CONFLICT(id) DO UPDATE SET
+        name = excluded.name,
+        enabled = excluded.enabled,
+        schedule_kind = excluded.schedule_kind,
+        schedule_expr = excluded.schedule_expr,
+        every_ms = excluded.every_ms,
+        at_iso = excluded.at_iso,
+        timezone = excluded.timezone,
+        run_mode = excluded.run_mode,
+        handler_key = excluded.handler_key,
+        condition_module_path = excluded.condition_module_path,
+        condition_description = excluded.condition_description,
+        agent_prompt_template = excluded.agent_prompt_template,
+        agent_model_override = excluded.agent_model_override,
+        max_attempts = excluded.max_attempts,
+        retry_backoff_ms = excluded.retry_backoff_ms,
+        payload_json = excluded.payload_json,
+        updated_at = excluded.updated_at
+    `,
+    )
+    .run(
+      HEARTBEAT_SYSTEM_JOB_ID,
+      HEARTBEAT_SYSTEM_JOB_NAME,
+      parseInterval(DEFAULT_HEARTBEAT_INTERVAL),
+      DEFAULT_HEARTBEAT_PROMPT,
+      3,
+      30_000,
+      JSON.stringify(buildDefaultHeartbeatPayload()),
+      createdAt,
+    );
+}
+
+export function deleteLegacyHeartbeatJobs() {
+  ensureCronTables();
+  sqlite
+    .query(
+      `
+      DELETE FROM cron_job_instances
+      WHERE job_definition_id = ?1
+         OR job_definition_id LIKE 'heartbeat-%'
+    `,
+    )
+    .run(HEARTBEAT_SYSTEM_JOB_ID);
+  const deleted = sqlite
+    .query(
+      `
+      DELETE FROM cron_job_definitions
+      WHERE id = ?1
+         OR id LIKE 'heartbeat-%'
+    `,
+    )
+    .run(HEARTBEAT_SYSTEM_JOB_ID).changes;
+  return deleted;
+}

package/apps/server/src/backend/heartbeat/heartbeat.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, test } from "bun:test";
+
+import { isActiveHours } from "./activeHours";
+import { deleteLegacyHeartbeatJobs, HEARTBEAT_SYSTEM_JOB_ID, seedDefaultHeartbeatJob } from "./defaultJob";
+import { parseInterval } from "./service";
+import type { HeartbeatConfig } from "./types";
+import { clearCronTables } from "../cron/storage";
+import { sqlite } from "../db/client";
+
+describe("parseInterval", () => {
+  test("parses minutes", () => {
+    expect(parseInterval("30m")).toBe(30 * 60 * 1000);
+  });
+
+  test("parses hours", () => {
+    expect(parseInterval("1h")).toBe(60 * 60 * 1000);
+  });
+
+  test("parses days", () => {
+    expect(parseInterval("1d")).toBe(24 * 60 * 60 * 1000);
+  });
+
+  test("parses zero minutes", () => {
+    expect(parseInterval("0m")).toBe(0);
+  });
+
+  test("rejects invalid format", () => {
+    expect(() => parseInterval("invalid")).toThrow();
+  });
+
+  test("rejects missing unit", () => {
+    expect(() => parseInterval("30")).toThrow();
+  });
+});
+
+describe("isActiveHours", () => {
+  test("returns true if no active hours config", () => {
+    const config: HeartbeatConfig = {
+      enabled: true,
+      interval: "30m",
+      prompt: "heartbeat",
+      ackMaxChars: 300,
+    };
+    expect(isActiveHours(config)).toBe(true);
+  });
+
+  test("returns true for always-on config (00:00-23:59)", () => {
+    const config: HeartbeatConfig = {
+      enabled: true,
+      interval: "30m",
+      prompt: "heartbeat",
+      ackMaxChars: 300,
+      activeHours: {
+        start: "00:00",
+        end: "23:59",
+        timezone: "UTC",
+      },
+    };
+    expect(isActiveHours(config)).toBe(true);
+  });
+});
+
+describe("legacy heartbeat cron cleanup", () => {
+  test("removes the reserved heartbeat cron job", () => {
+    clearCronTables();
+    const createdAt = Date.now();
+    seedDefaultHeartbeatJob(createdAt);
+
+    expect(deleteLegacyHeartbeatJobs()).toBe(1);
+    const remaining = sqlite
+      .query(
+        `
+        SELECT COUNT(*) as count
+        FROM cron_job_definitions
+        WHERE id = ?1
+      `,
+      )
+      .get(HEARTBEAT_SYSTEM_JOB_ID) as { count: number };
+    expect(remaining.count).toBe(0);
+  });
+
+  test("removes legacy heartbeat-prefixed jobs", () => {
+    clearCronTables();
+    sqlite
+      .query(
+        `
+        INSERT INTO cron_job_definitions (
+          id, name, thread_session_id, enabled, schedule_kind, schedule_expr, every_ms, at_iso, timezone,
+          run_mode, handler_key, condition_module_path, condition_description, agent_prompt_template, agent_model_override,
+          max_attempts, retry_backoff_ms, payload_json, last_enqueued_for, created_at, updated_at
+        )
+        VALUES (?1, ?2, NULL, 1, 'every', NULL, ?3, NULL, NULL, 'background', 'heartbeat.check', NULL, NULL, NULL, NULL, 3, 30000, '{}', NULL, ?4, ?4)
+      `,
+      )
+      .run("heartbeat-build", "Heartbeat: build", parseInterval("30m"), Date.now());
+
+    expect(deleteLegacyHeartbeatJobs()).toBe(1);
+
+    const rows = sqlite
+      .query(
+        `
+        SELECT id
+        FROM cron_job_definitions
+        ORDER BY id
+      `,
+      )
+      .all() as Array<{ id: string }>;
+    expect(rows).toEqual([]);
+  });
+});