@evo-dev/core 0.0.1-alpha → 0.0.1-alpha.10

package/src/daemon/index.ts

@@ -2,7 +2,24 @@ import { randomBytes } from "node:crypto";
 import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { type IncomingMessage, createServer } from "node:http";
 import { dirname, join } from "node:path";
+import { listEvolutionTriggers, processEvolutionTriggers } from "../evolution/control/index.ts";
 import { listObservabilityEvents } from "../observability/index.ts";
+import {
+  type TeamRuntimeAdapter,
+  isActiveTeamAgentStatus,
+  isIdleTeamAgentStatus,
+  isMidTurnTeamAgentStatus,
+  listTeamRuns,
+  markTeamMessagesDelivered,
+  readPendingTeamMessagesForRole,
+  reconcileTeamRun,
+  resumeTeamRun,
+  schedulePendingTeamMessageDelivery,
+  sendTeamMessage,
+  spawnTeamRole,
+  stopTeamRole,
+  updateTeamAgentHookState,
+} from "../team/index.ts";
 
 export interface DaemonPaths {
   rootDir: string;
@@ -43,6 +60,15 @@ export interface DaemonRequestInput {
   token?: string | null;
   homeDir: string;
   origin?: string | null;
+  body?: unknown;
+  runtimeAdapter?: TeamRuntimeAdapter;
+}
+
+interface DaemonTeamStatusSummary {
+  run: unknown;
+  agents: unknown[];
+  stoppedAgents: string[];
+  notifications: unknown[];
 }
 
 const DEFAULT_PORT = 37645;
@@ -163,10 +189,68 @@ export async function handleDaemonRequest(
     const removed = await cleanupDaemonState(input.homeDir, input.token ?? "");
     return ok({ stopped: true, removed }, warnings);
   }
+  if (
+    (input.path === "/team/message/enqueue" || input.path === "/teams/send") &&
+    input.method === "POST"
+  ) {
+    return dashboardMutation(
+      await sendDashboardTeamMessage(input.homeDir, input.body, input.runtimeAdapter),
+      warnings,
+    );
+  }
+  if (input.path === "/team/agent/state" && input.method === "POST") {
+    return dashboardMutation(
+      await updateDashboardTeamAgentState(input.homeDir, input.body),
+      warnings,
+    );
+  }
+  if (input.path === "/team/message/claim" && input.method === "POST") {
+    return ok(await claimDashboardTeamMessages(input.homeDir, input.body), warnings);
+  }
+  if (input.path === "/team/message/delivered" && input.method === "POST") {
+    return dashboardMutation(
+      await markDashboardTeamMessagesDelivered(input.homeDir, input.body),
+      warnings,
+    );
+  }
+  if (
+    (input.path === "/team/reconcile" || input.path === "/teams/reconcile") &&
+    input.method === "POST"
+  ) {
+    await schedulePendingTeamMessageDelivery({
+      homeDir: input.homeDir,
+      runtimeAdapter: input.runtimeAdapter,
+    }).catch((error) =>
+      warnings.push(`Team delivery scheduling unavailable: ${describeError(error)}`),
+    );
+    return ok(await collectTeamStatus(input.homeDir, warnings, input.runtimeAdapter), warnings);
+  }
+  if (input.path === "/teams/spawn" && input.method === "POST") {
+    return dashboardMutation(
+      await spawnDashboardTeamRole(input.homeDir, input.body, input.runtimeAdapter),
+      warnings,
+    );
+  }
+  if (input.path === "/teams/stop-role" && input.method === "POST") {
+    return dashboardMutation(
+      await stopDashboardTeamRole(input.homeDir, input.body, input.runtimeAdapter),
+      warnings,
+    );
+  }
+  if (input.path === "/teams/resume" && input.method === "POST") {
+    return dashboardMutation(
+      await resumeDashboardTeamRun(input.homeDir, input.body, input.runtimeAdapter),
+      warnings,
+    );
+  }
+  if (input.path === "/evolution/process" && input.method === "POST") {
+    return dashboardMutation(
+      await processDashboardEvolutionTriggers(input.homeDir, input.body),
+      warnings,
+    );
+  }
   if (input.method !== "GET") return notFound(warnings);
 
-  if (input.path === "/tasks")
-    return ok(await collectTaskSummaries(input.homeDir, warnings), warnings);
   if (input.path === "/observability/events")
     return ok(await collectObservabilitySummaries(input.homeDir, warnings), warnings);
   if (input.path === "/memory/candidates")
@@ -181,8 +265,16 @@ export async function handleDaemonRequest(
       await collectDirectorySummaries(join(input.homeDir, ".evodev", "PACKS"), warnings),
       warnings,
     );
-  if (input.path === "/runs") return ok([], warnings);
-  if (input.path === "/agents") return ok([], warnings);
+  if (input.path === "/runs") return ok(await collectTeamRuns(input.homeDir, warnings), warnings);
+  if (input.path === "/evolution/triggers")
+    return ok(await collectEvolutionTriggers(input.homeDir, warnings), warnings);
+  if (input.path === "/agents")
+    return ok(
+      (await collectTeamStatus(input.homeDir, warnings, input.runtimeAdapter)).agents,
+      warnings,
+    );
+  if (input.path === "/teams/status")
+    return ok(await collectTeamStatus(input.homeDir, warnings, input.runtimeAdapter), warnings);
 
   return notFound(warnings);
 }
@@ -211,6 +303,7 @@ export async function runDaemonForeground(input: {
           url.searchParams.get("token"),
         homeDir: input.homeDir,
         origin: readHeader(request, "origin"),
+        body: await readJsonBody(request),
       });
 
       response.writeHead(result.status, { "content-type": "application/json" });
@@ -248,8 +341,22 @@ export async function runDaemonForeground(input: {
   input.write?.(
     `Daemon listening on ${state.lock.host}:${state.lock.port}; token path: ${state.paths.tokenPath}`,
   );
+  const reconcileInterval = setInterval(() => {
+    void reconcileTeamRun({ homeDir: input.homeDir }).catch(() => undefined);
+  }, 2_000);
+  reconcileInterval.unref();
+  const evolutionInterval = setInterval(() => {
+    void processEvolutionTriggers({ homeDir: input.homeDir, limit: 20 })
+      .then(() => clearDaemonEvolutionProcessError(input.homeDir))
+      .catch((error) => recordDaemonEvolutionProcessError(input.homeDir, error));
+  }, 5_000);
+  evolutionInterval.unref();
   await new Promise<void>((resolve, reject) => {
-    server.once("close", resolve);
+    server.once("close", () => {
+      clearInterval(reconcileInterval);
+      clearInterval(evolutionInterval);
+      resolve();
+    });
     server.once("error", reject);
   });
 }
@@ -264,6 +371,22 @@ function createDaemonToken(): string {
   return randomBytes(32).toString("hex");
 }
 
+async function readJsonBody(request: IncomingMessage): Promise<unknown> {
+  if (request.method === "GET" || request.method === "HEAD") return undefined;
+  const chunks: Buffer[] = [];
+  let totalBytes = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    totalBytes += buffer.length;
+    if (totalBytes > 64 * 1024) throw new Error("Request body too large.");
+    chunks.push(buffer);
+  }
+  if (chunks.length === 0) return undefined;
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (raw === "") return undefined;
+  return JSON.parse(raw);
+}
+
 async function authorize(homeDir: string, token: string | null): Promise<{ ok: boolean }> {
   const expected = await readDaemonToken(homeDir);
   return { ok: expected !== null && token !== null && token === expected };
@@ -282,33 +405,6 @@ function isAllowedLocalOrigin(origin: string | null): boolean {
   }
 }
 
-async function collectTaskSummaries(homeDir: string, warnings: string[]): Promise<unknown[]> {
-  const root = join(homeDir, ".evodev", "STATE", "tasks");
-  if (!(await pathExists(root))) {
-    warnings.push("Task store not found; returning empty tasks.");
-    return [];
-  }
-  const contracts = await collectNamedFiles(root, "contract.json");
-  const summaries: unknown[] = [];
-  for (const file of contracts) {
-    try {
-      const contract = JSON.parse(await readFile(file, "utf8"));
-      summaries.push(
-        sanitizeMetadata({
-          taskId: contract.taskId,
-          status: contract.status,
-          mode: contract.route?.mode ?? null,
-          workflowId: contract.route?.workflowId ?? null,
-          verificationStatus: contract.verification?.status ?? null,
-        }),
-      );
-    } catch {
-      warnings.push(`Skipped unreadable task contract: ${file}`);
-    }
-  }
-  return summaries;
-}
-
 async function collectObservabilitySummaries(
   homeDir: string,
   warnings: string[],
@@ -352,6 +448,258 @@ async function collectLearningCandidateSummaries(
   });
 }
 
+async function collectEvolutionTriggers(homeDir: string, warnings: string[]): Promise<unknown[]> {
+  const lastError = await readDaemonEvolutionProcessError(homeDir).catch(() => null);
+  if (lastError !== null) warnings.push(`Evolution processor last error: ${lastError}`);
+  try {
+    return (await listEvolutionTriggers({ homeDir })).map((trigger) =>
+      sanitizeMetadata({
+        id: trigger.id,
+        projectKey: trigger.projectKey,
+        runId: trigger.runId,
+        roleId: trigger.roleId,
+        taskId: trigger.taskId,
+        eventType: trigger.eventType,
+        triggerStrength: trigger.triggerStrength,
+        triggerReason: trigger.triggerReason,
+        status: trigger.status,
+        attempts: trigger.attempts,
+        createdAt: trigger.createdAt,
+        updatedAt: trigger.updatedAt,
+      }),
+    );
+  } catch (error) {
+    warnings.push(`Evolution triggers unavailable: ${describeError(error)}`);
+    return [];
+  }
+}
+
+async function processDashboardEvolutionTriggers(homeDir: string, body: unknown): Promise<unknown> {
+  if (body === undefined) {
+    return {
+      ok: false,
+      error: "evolution process requires JSON body with dryRun=true or confirm=true.",
+    };
+  }
+  const input = expectRequestBody(body);
+  const dryRun = optionalBodyBoolean(input.dryRun) === true;
+  const confirm = optionalBodyBoolean(input.confirm) === true;
+  if (!dryRun && !confirm) {
+    return {
+      ok: false,
+      error: "evolution process requires dryRun=true or confirm=true.",
+    };
+  }
+  return processEvolutionTriggers({
+    homeDir,
+    projectKey: optionalBodyString(input.projectKey),
+    runId: optionalBodyString(input.runId),
+    limit: optionalBodyNumber(input.limit),
+    dryRun,
+  });
+}
+
+async function collectTeamRuns(homeDir: string, warnings: string[]): Promise<unknown[]> {
+  try {
+    return (await listTeamRuns({ homeDir })).map((run) =>
+      sanitizeMetadata({
+        runId: run.runId,
+        status: run.status,
+        repoRoot: run.repoRoot,
+        mainAgentId: run.mainAgentId,
+        session: run.tmux.session,
+        roleCount: Object.keys(run.roles).length,
+        createdAt: run.createdAt,
+        updatedAt: run.updatedAt,
+      }),
+    );
+  } catch (error) {
+    warnings.push(`Team runs unavailable: ${describeError(error)}`);
+    return [];
+  }
+}
+
+async function collectTeamStatus(
+  homeDir: string,
+  warnings: string[],
+  runtimeAdapter?: TeamRuntimeAdapter,
+): Promise<DaemonTeamStatusSummary> {
+  try {
+    const status = await reconcileTeamRun({ homeDir, runtimeAdapter });
+    return sanitizeMetadata({
+      run:
+        status.run === null
+          ? null
+          : {
+              runId: status.run.runId,
+              status: status.run.status,
+              repoRoot: status.run.repoRoot,
+              session: status.run.tmux.session,
+              updatedAt: status.run.updatedAt,
+            },
+      agents: status.agents.map((agent) => ({
+        roleId: agent.roleId,
+        roleName: agent.roleName,
+        runId: agent.runId,
+        runtime: agent.runtime,
+        model: agent.model,
+        thinkingLevel: agent.thinkingLevel,
+        status: agent.status,
+        paneId: agent.tmux.paneId,
+        canReceiveMessages: isActiveTeamAgentStatus(agent.status),
+        isIdle: isIdleTeamAgentStatus(agent.status),
+        isMidTurn: isMidTurnTeamAgentStatus(agent.status),
+        nativeSessionRecorded: agent.nativeSession.sessionId !== null,
+        updatedAt: agent.updatedAt,
+      })),
+      stoppedAgents: status.stoppedAgents.map((agent) => agent.roleId),
+      notifications: status.notifications.map((notification) => ({
+        ok: notification.ok,
+        error: notification.error ?? null,
+        delivery: notification.delivery ?? null,
+        queuedFor: notification.queuedFor ?? null,
+      })),
+    }) as DaemonTeamStatusSummary;
+  } catch (error) {
+    warnings.push(`Team status unavailable: ${describeError(error)}`);
+    return { run: null, agents: [], stoppedAgents: [], notifications: [] };
+  }
+}
+
+async function sendDashboardTeamMessage(
+  homeDir: string,
+  body: unknown,
+  runtimeAdapter?: TeamRuntimeAdapter,
+): Promise<unknown> {
+  const input = expectRequestBody(body);
+  return sendTeamMessage({
+    homeDir,
+    runId: optionalBodyString(input.runId),
+    fromRoleId: "user",
+    toRoleId: expectBodyString(input, "toRoleId"),
+    message: expectBodyString(input, "message"),
+    runtimeAdapter,
+  });
+}
+
+async function updateDashboardTeamAgentState(homeDir: string, body: unknown): Promise<unknown> {
+  const input = expectRequestBody(body);
+  const result = await updateTeamAgentHookState({
+    homeDir,
+    runId: expectBodyString(input, "runId"),
+    roleId: expectBodyString(input, "roleId"),
+    hookEvent: expectBodyString(input, "hookEvent"),
+  });
+  return {
+    ok: true,
+    roleId: result.agent.roleId,
+    status: result.agent.status,
+    statusPath: result.statusPath,
+  };
+}
+
+async function claimDashboardTeamMessages(homeDir: string, body: unknown): Promise<unknown> {
+  const input = expectRequestBody(body);
+  const runId = expectBodyString(input, "runId");
+  const roleId = expectBodyString(input, "roleId");
+  const messages = await readPendingTeamMessagesForRole({
+    homeDir,
+    runId,
+    roleId,
+    limit: optionalBodyNumber(input.limit),
+  });
+  return {
+    runId,
+    roleId,
+    messages,
+  };
+}
+
+async function markDashboardTeamMessagesDelivered(
+  homeDir: string,
+  body: unknown,
+): Promise<unknown> {
+  const input = expectRequestBody(body);
+  const messageIdsValue = input.messageIds;
+  if (!Array.isArray(messageIdsValue)) throw new Error("Expected body.messageIds array.");
+  const messageIds = messageIdsValue.map((value) => {
+    if (typeof value !== "string" || value.length === 0) {
+      throw new Error("Expected body.messageIds to contain non-empty strings.");
+    }
+    return value;
+  });
+  await markTeamMessagesDelivered({
+    homeDir,
+    runId: expectBodyString(input, "runId"),
+    roleId: expectBodyString(input, "roleId"),
+    messageIds,
+  });
+  return { ok: true, delivered: messageIds };
+}
+
+async function spawnDashboardTeamRole(
+  homeDir: string,
+  body: unknown,
+  runtimeAdapter?: TeamRuntimeAdapter,
+): Promise<unknown> {
+  const input = expectRequestBody(body);
+  const roleId = expectBodyString(input, "roleId");
+  const status = await reconcileTeamRun({
+    homeDir,
+    runId: optionalBodyString(input.runId),
+    runtimeAdapter,
+    notifyMain: false,
+  });
+  if (status.run === null) return { ok: false, error: "team-run-not-found" };
+  if (status.run.status !== "running") return { ok: false, error: "team-run-not-running" };
+  const result = await spawnTeamRole({
+    homeDir,
+    repoRoot: status.run.repoRoot,
+    runId: status.run.runId,
+    roleId,
+    runtimeAdapter,
+  });
+  return { ok: true, created: result.created, agent: result.agent };
+}
+
+async function stopDashboardTeamRole(
+  homeDir: string,
+  body: unknown,
+  runtimeAdapter?: TeamRuntimeAdapter,
+): Promise<unknown> {
+  const input = expectRequestBody(body);
+  return stopTeamRole({
+    homeDir,
+    runId: optionalBodyString(input.runId),
+    roleId: expectBodyString(input, "roleId"),
+    runtimeAdapter,
+  });
+}
+
+async function resumeDashboardTeamRun(
+  homeDir: string,
+  body: unknown,
+  runtimeAdapter?: TeamRuntimeAdapter,
+): Promise<unknown> {
+  const input = expectRequestBody(body);
+  const decision = optionalBodyString(input.onSessionMissing);
+  if (decision !== undefined && !["ask", "fail", "recreate", "resume-latest"].includes(decision)) {
+    return { ok: false, error: "invalid-on-session-missing" };
+  }
+  const result = await resumeTeamRun({
+    homeDir,
+    runId: optionalBodyString(input.runId),
+    runtimeAdapter,
+    missingSessionDecision: decision as "ask" | "fail" | "recreate" | "resume-latest" | undefined,
+  });
+  return {
+    ok: result.decisionRequired.length === 0,
+    run: result.run,
+    outcomes: result.outcomes,
+    decisionRequired: result.decisionRequired,
+  };
+}
+
 async function collectDirectorySummaries(root: string, warnings: string[]): Promise<unknown[]> {
   if (!(await pathExists(root))) {
     warnings.push(`Store not found: ${root}`);
@@ -379,15 +727,89 @@ function sanitizeMetadata(value: unknown): unknown {
   return output;
 }
 
-async function collectNamedFiles(root: string, name: string): Promise<string[]> {
-  const entries = await readdir(root, { withFileTypes: true });
-  const files: string[] = [];
-  for (const entry of entries) {
-    const path = join(root, entry.name);
-    if (entry.isDirectory()) files.push(...(await collectNamedFiles(path, name)));
-    else if (entry.isFile() && entry.name === name) files.push(path);
+function dashboardMutation(
+  data: unknown,
+  warnings: string[],
+): { status: number; body: DaemonResponseBody } {
+  const okResult = !(
+    typeof data === "object" &&
+    data !== null &&
+    "ok" in data &&
+    (data as { ok?: unknown }).ok === false
+  );
+  return {
+    status: okResult ? 200 : 400,
+    body: { ok: okResult, data: sanitizeMetadata(data), warnings },
+  };
+}
+
+function expectRequestBody(value: unknown): Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("Expected JSON object request body.");
   }
-  return files;
+  return value as Record<string, unknown>;
+}
+
+function expectBodyString(input: Record<string, unknown>, key: string): string {
+  const value = input[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Expected non-empty string body.${key}.`);
+  }
+  return value;
+}
+
+function optionalBodyString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function optionalBodyNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+
+function optionalBodyBoolean(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined;
+}
+
+function resolveDaemonEvolutionProcessErrorPath(homeDir: string): string {
+  return join(resolveDaemonPaths(homeDir).rootDir, "evolution-process-error.json");
+}
+
+async function recordDaemonEvolutionProcessError(homeDir: string, error: unknown): Promise<void> {
+  try {
+    const path = resolveDaemonEvolutionProcessErrorPath(homeDir);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(
+      path,
+      `${JSON.stringify(
+        {
+          schemaVersion: 1,
+          kind: "daemon-evolution-process-error",
+          updatedAt: new Date().toISOString(),
+          summary: sanitizeMetadata(describeError(error)),
+        },
+        null,
+        2,
+      )}\n`,
+      { encoding: "utf8", flag: "w", mode: 0o600 },
+    );
+  } catch {
+    // Daemon background diagnostics must not affect foreground request handling.
+  }
+}
+
+async function clearDaemonEvolutionProcessError(homeDir: string): Promise<void> {
+  await rm(resolveDaemonEvolutionProcessErrorPath(homeDir), { force: true }).catch(() => undefined);
+}
+
+async function readDaemonEvolutionProcessError(homeDir: string): Promise<string | null> {
+  const path = resolveDaemonEvolutionProcessErrorPath(homeDir);
+  if (!(await pathExists(path))) return null;
+  const value = JSON.parse(await readFile(path, "utf8")) as { summary?: unknown };
+  return typeof value.summary === "string" && value.summary.length > 0 ? value.summary : null;
+}
+
+function describeError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
 }
 
 function ok(data: unknown, warnings: string[]): { status: number; body: DaemonResponseBody } {