@evo-dev/core 0.0.1-alpha

package/src/config/store.ts

@@ -0,0 +1,166 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { EvoDevConfigError } from "./errors.ts";
+import { type EvoDevPaths, resolveEvoDevPaths } from "./paths.ts";
+import { type EvoDevRegistry, createDefaultRegistry, parseRegistry } from "./registry.ts";
+import {
+  type EvoDevSettings,
+  type SettingsInput,
+  createDefaultSettings,
+  mergeSettings,
+  parseSettings,
+} from "./settings.ts";
+import {
+  type InstallState,
+  type SyncState,
+  createDefaultInstallState,
+  createDefaultSyncState,
+  parseInstallState,
+  parseSyncState,
+} from "./state.ts";
+
+export interface CoreConfigStore {
+  readonly paths: EvoDevPaths;
+  ensureBaseDirs(): Promise<void>;
+  readSettings(): Promise<EvoDevSettings>;
+  writeSettings(settings: EvoDevSettings): Promise<void>;
+  mergeAndWriteSettings(input: SettingsInput): Promise<EvoDevSettings>;
+  readRegistry(): Promise<EvoDevRegistry>;
+  writeRegistry(registry: EvoDevRegistry): Promise<void>;
+  readInstallState(): Promise<InstallState>;
+  writeInstallState(state: InstallState): Promise<void>;
+  readSyncState(): Promise<SyncState>;
+  writeSyncState(state: SyncState): Promise<void>;
+}
+
+export function createCoreConfigStore(homeDir?: string): CoreConfigStore {
+  const paths = resolveEvoDevPaths(homeDir);
+
+  return {
+    paths,
+    async ensureBaseDirs() {
+      await mkdir(paths.stateDir, { recursive: true });
+    },
+    async readSettings() {
+      return readJsonFile(paths.settingsPath, parseSettings);
+    },
+    async writeSettings(settings) {
+      await writeJsonFile(paths.settingsPath, parseSettings(settings));
+    },
+    async mergeAndWriteSettings(input) {
+      const current = await readJsonFileOrDefault(
+        paths.settingsPath,
+        parseSettings,
+        createDefaultSettings(),
+      );
+      const merged = mergeSettings(input, current);
+      await writeJsonFile(paths.settingsPath, merged);
+      return merged;
+    },
+    async readRegistry() {
+      return readJsonFile(paths.registryPath, parseRegistry);
+    },
+    async writeRegistry(registry) {
+      await writeJsonFile(paths.registryPath, parseRegistry(registry));
+    },
+    async readInstallState() {
+      return readJsonFile(paths.installStatePath, parseInstallState);
+    },
+    async writeInstallState(state) {
+      await writeJsonFile(paths.installStatePath, parseInstallState(state));
+    },
+    async readSyncState() {
+      return readJsonFile(paths.syncStatePath, parseSyncState);
+    },
+    async writeSyncState(state) {
+      await writeJsonFile(paths.syncStatePath, parseSyncState(state));
+    },
+  };
+}
+
+export async function initializeCoreConfig(homeDir?: string): Promise<CoreConfigStore> {
+  const store = createCoreConfigStore(homeDir);
+  await store.ensureBaseDirs();
+  await writeIfMissing(store.paths.settingsPath, createDefaultSettings());
+  await writeIfMissing(store.paths.registryPath, createDefaultRegistry());
+  await writeIfMissing(store.paths.installStatePath, createDefaultInstallState());
+  await writeIfMissing(store.paths.syncStatePath, createDefaultSyncState());
+  return store;
+}
+
+async function readJsonFile<T>(filePath: string, parse: (value: unknown) => T): Promise<T> {
+  let raw: string;
+
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch (error) {
+    throw new EvoDevConfigError(`Cannot read config file (${describeFileError(error)})`, filePath);
+  }
+
+  let json: unknown;
+
+  try {
+    json = JSON.parse(raw);
+  } catch (error) {
+    throw new EvoDevConfigError(`Invalid JSON (${describeFileError(error)})`, filePath);
+  }
+
+  try {
+    return parse(json);
+  } catch (error) {
+    if (error instanceof EvoDevConfigError) {
+      throw new EvoDevConfigError(error.message, filePath);
+    }
+
+    throw error;
+  }
+}
+
+async function readJsonFileOrDefault<T>(
+  filePath: string,
+  parse: (value: unknown) => T,
+  fallback: T,
+): Promise<T> {
+  try {
+    return await readJsonFile(filePath, parse);
+  } catch (error) {
+    if (error instanceof EvoDevConfigError && error.message.includes("ENOENT")) {
+      return fallback;
+    }
+
+    throw error;
+  }
+}
+
+async function writeIfMissing(filePath: string, value: unknown): Promise<void> {
+  try {
+    await readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      await writeJsonFile(filePath, value);
+      return;
+    }
+
+    throw new EvoDevConfigError(
+      `Cannot inspect config file (${describeFileError(error)})`,
+      filePath,
+    );
+  }
+}
+
+async function writeJsonFile(filePath: string, value: unknown): Promise<void> {
+  await mkdir(dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+function describeFileError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  return String(error);
+}
+
+function isNodeError(error: unknown): error is NodeJS.ErrnoException {
+  return error instanceof Error && "code" in error;
+}

package/src/daemon/index.ts

@@ -0,0 +1,414 @@
+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 { listObservabilityEvents } from "../observability/index.ts";
+
+export interface DaemonPaths {
+  rootDir: string;
+  lockPath: string;
+  tokenPath: string;
+}
+
+export interface DaemonLock {
+  version: 1;
+  component: "evodev-daemon";
+  pid: number;
+  host: "127.0.0.1" | "localhost";
+  port: number;
+  startedAt: string;
+  heartbeatAt: string;
+  status: "running";
+  tokenPath: string;
+  versionText: string;
+}
+
+export interface DaemonStartPlan {
+  host: "127.0.0.1" | "localhost";
+  port: number;
+  paths: DaemonPaths;
+  writes: string[];
+  warnings: string[];
+}
+
+export interface DaemonResponseBody {
+  ok: boolean;
+  data: unknown;
+  warnings: string[];
+}
+
+export interface DaemonRequestInput {
+  method: string;
+  path: string;
+  token?: string | null;
+  homeDir: string;
+  origin?: string | null;
+}
+
+const DEFAULT_PORT = 37645;
+const SENSITIVE_TEXT_PATTERN =
+  /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw output|raw source|raw prompt|transcript|stdout|stderr)\b/i;
+
+export function resolveDaemonPaths(homeDir: string): DaemonPaths {
+  const rootDir = join(homeDir, ".evodev", "STATE", "daemon");
+  return { rootDir, lockPath: join(rootDir, "lock.json"), tokenPath: join(rootDir, "token") };
+}
+
+export function validateDaemonBindHost(host: string): "127.0.0.1" | "localhost" {
+  if (host === "127.0.0.1" || host === "localhost") return host;
+  throw new Error("Daemon bind host must be local-only: 127.0.0.1 or localhost.");
+}
+
+export function createDaemonStartPlan(input: {
+  homeDir: string;
+  host?: string;
+  port?: number;
+}): DaemonStartPlan {
+  const host = validateDaemonBindHost(input.host ?? "127.0.0.1");
+  const port = input.port ?? DEFAULT_PORT;
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) throw new Error("Invalid daemon port.");
+  const paths = resolveDaemonPaths(input.homeDir);
+  return {
+    host,
+    port,
+    paths,
+    writes: [paths.lockPath, paths.tokenPath],
+    warnings: ["Daemon is disabled by default and starts only via explicit daemon start."],
+  };
+}
+
+export async function writeDaemonState(input: {
+  homeDir: string;
+  host?: string;
+  port?: number;
+  now?: string;
+  pid?: number;
+  versionText?: string;
+}): Promise<{ lock: DaemonLock; token: string; paths: DaemonPaths }> {
+  const plan = createDaemonStartPlan(input);
+  if ((await readDaemonLock(input.homeDir)) !== null) {
+    throw new Error("Existing daemon lock found; refusing to overwrite daemon state.");
+  }
+  const token = createDaemonToken();
+  const now = input.now ?? new Date().toISOString();
+  const lock: DaemonLock = {
+    version: 1,
+    component: "evodev-daemon",
+    pid: input.pid ?? process.pid,
+    host: plan.host,
+    port: plan.port,
+    startedAt: now,
+    heartbeatAt: now,
+    status: "running",
+    tokenPath: plan.paths.tokenPath,
+    versionText: input.versionText ?? "evodev 0.0.1-alpha",
+  };
+  await mkdir(dirname(plan.paths.lockPath), { recursive: true });
+  await writeFile(plan.paths.tokenPath, `${token}\n`, {
+    encoding: "utf8",
+    flag: "wx",
+    mode: 0o600,
+  });
+  await writeFile(plan.paths.lockPath, `${JSON.stringify(lock, null, 2)}\n`, {
+    encoding: "utf8",
+    flag: "wx",
+    mode: 0o600,
+  });
+  return { lock, token, paths: plan.paths };
+}
+
+export async function readDaemonLock(homeDir: string): Promise<DaemonLock | null> {
+  const paths = resolveDaemonPaths(homeDir);
+  if (!(await pathExists(paths.lockPath))) return null;
+  const lock = JSON.parse(await readFile(paths.lockPath, "utf8")) as DaemonLock;
+  if (lock.version !== 1 || lock.component !== "evodev-daemon")
+    throw new Error("Invalid daemon lock.");
+  return lock;
+}
+
+export async function readDaemonToken(homeDir: string): Promise<string | null> {
+  const paths = resolveDaemonPaths(homeDir);
+  if (!(await pathExists(paths.tokenPath))) return null;
+  return (await readFile(paths.tokenPath, "utf8")).trim();
+}
+
+export async function cleanupDaemonState(homeDir: string, token: string): Promise<string[]> {
+  const paths = resolveDaemonPaths(homeDir);
+  const currentToken = await readDaemonToken(homeDir);
+  if (currentToken === null || currentToken !== token) throw new Error("Invalid daemon token.");
+  const lock = await readDaemonLock(homeDir);
+  if (lock === null || lock.component !== "evodev-daemon")
+    throw new Error("Missing valid daemon lock.");
+  await rm(paths.lockPath, { force: true });
+  await rm(paths.tokenPath, { force: true });
+  return [paths.lockPath, paths.tokenPath];
+}
+
+export async function handleDaemonRequest(
+  input: DaemonRequestInput,
+): Promise<{ status: number; body: DaemonResponseBody }> {
+  const warnings: string[] = [];
+  if (!isAllowedLocalOrigin(input.origin ?? null)) {
+    return { status: 403, body: { ok: false, data: { error: "forbidden origin" }, warnings } };
+  }
+  if (input.path === "/health" && input.method === "GET") {
+    return ok({ status: "ok", version: 1, metadataOnly: true }, warnings);
+  }
+
+  const auth = await authorize(input.homeDir, input.token ?? null);
+  if (!auth.ok)
+    return { status: 401, body: { ok: false, data: { error: "unauthorized" }, warnings } };
+
+  if (input.path === "/shutdown" && input.method === "POST") {
+    const removed = await cleanupDaemonState(input.homeDir, input.token ?? "");
+    return ok({ stopped: true, removed }, 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")
+    return ok(await collectLearningCandidateSummaries(input.homeDir, warnings), warnings);
+  if (input.path === "/projects")
+    return ok(
+      await collectDirectorySummaries(join(input.homeDir, ".evodev", "PROJECTS"), warnings),
+      warnings,
+    );
+  if (input.path === "/packs")
+    return ok(
+      await collectDirectorySummaries(join(input.homeDir, ".evodev", "PACKS"), warnings),
+      warnings,
+    );
+  if (input.path === "/runs") return ok([], warnings);
+  if (input.path === "/agents") return ok([], warnings);
+
+  return notFound(warnings);
+}
+
+export async function runDaemonForeground(input: {
+  homeDir: string;
+  host?: string;
+  port?: number;
+  write?: (message: string) => void;
+}): Promise<void> {
+  const state = await writeDaemonState({
+    homeDir: input.homeDir,
+    host: input.host,
+    port: input.port,
+  });
+
+  const server = createServer(async (request, response) => {
+    try {
+      const url = new URL(request.url ?? "/", `http://${state.lock.host}:${state.lock.port}`);
+      const result = await handleDaemonRequest({
+        method: request.method ?? "GET",
+        path: url.pathname,
+        token:
+          readHeader(request, "authorization")?.replace(/^Bearer\s+/i, "") ??
+          readHeader(request, "x-evodev-token") ??
+          url.searchParams.get("token"),
+        homeDir: input.homeDir,
+        origin: readHeader(request, "origin"),
+      });
+
+      response.writeHead(result.status, { "content-type": "application/json" });
+      response.end(JSON.stringify(result.body));
+
+      if (url.pathname === "/shutdown" && result.status === 200) {
+        server.close();
+      }
+    } catch (error) {
+      response.writeHead(500, { "content-type": "application/json" });
+      response.end(
+        JSON.stringify({
+          ok: false,
+          data: { error: error instanceof Error ? error.message : String(error) },
+          warnings: [],
+        }),
+      );
+    }
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    const onError = (error: Error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(state.lock.port, state.lock.host);
+  });
+
+  input.write?.(
+    `Daemon listening on ${state.lock.host}:${state.lock.port}; token path: ${state.paths.tokenPath}`,
+  );
+  await new Promise<void>((resolve, reject) => {
+    server.once("close", resolve);
+    server.once("error", reject);
+  });
+}
+
+function readHeader(request: IncomingMessage, name: string): string | null {
+  const value = request.headers[name.toLowerCase()];
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value ?? null;
+}
+
+function createDaemonToken(): string {
+  return randomBytes(32).toString("hex");
+}
+
+async function authorize(homeDir: string, token: string | null): Promise<{ ok: boolean }> {
+  const expected = await readDaemonToken(homeDir);
+  return { ok: expected !== null && token !== null && token === expected };
+}
+
+function isAllowedLocalOrigin(origin: string | null): boolean {
+  if (origin === null || origin === "") return true;
+  try {
+    const parsed = new URL(origin);
+    return (
+      (parsed.protocol === "http:" || parsed.protocol === "https:") &&
+      (parsed.hostname === "127.0.0.1" || parsed.hostname === "localhost")
+    );
+  } catch {
+    return false;
+  }
+}
+
+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[],
+): Promise<unknown[]> {
+  try {
+    return (await listObservabilityEvents(homeDir)).map((event) =>
+      sanitizeMetadata({
+        eventId: event.eventId,
+        type: event.type,
+        timestamp: event.timestamp,
+        summary: event.summary,
+        scope: event.scope ?? {},
+      }),
+    );
+  } catch (error) {
+    warnings.push(
+      `Observability unavailable: ${error instanceof Error ? error.message : String(error)}`,
+    );
+    return [];
+  }
+}
+
+async function collectLearningCandidateSummaries(
+  homeDir: string,
+  warnings: string[],
+): Promise<unknown[]> {
+  const path = join(homeDir, ".evodev", "STATE", "learning", "candidates.jsonl");
+  if (!(await pathExists(path))) {
+    warnings.push("Learning candidate store not found; returning empty candidates.");
+    return [];
+  }
+  const lines = (await readFile(path, "utf8")).split("\n").filter(Boolean);
+  return lines.map((line) => {
+    const candidate = JSON.parse(line);
+    return sanitizeMetadata({
+      id: candidate.id,
+      kind: candidate.kind,
+      status: candidate.status,
+      scope: candidate.scope,
+    });
+  });
+}
+
+async function collectDirectorySummaries(root: string, warnings: string[]): Promise<unknown[]> {
+  if (!(await pathExists(root))) {
+    warnings.push(`Store not found: ${root}`);
+    return [];
+  }
+  const entries = await readdir(root, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => ({ id: entry.name, metadataOnly: true }));
+}
+
+function sanitizeMetadata(value: unknown): unknown {
+  if (typeof value === "string") {
+    if (SENSITIVE_TEXT_PATTERN.test(value)) return "[redacted]";
+    return value.slice(0, 500);
+  }
+  if (Array.isArray(value)) return value.map(sanitizeMetadata);
+  if (typeof value !== "object" || value === null) return value;
+  const output: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (/raw|prompt|source|stdout|stderr|secret|token|password|transcript|memorybody/i.test(key))
+      continue;
+    output[key] = sanitizeMetadata(child);
+  }
+  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);
+  }
+  return files;
+}
+
+function ok(data: unknown, warnings: string[]): { status: number; body: DaemonResponseBody } {
+  return { status: 200, body: { ok: true, data: sanitizeMetadata(data), warnings } };
+}
+
+function notFound(warnings: string[]): { status: number; body: DaemonResponseBody } {
+  return { status: 404, body: { ok: false, data: { error: "not found" }, warnings } };
+}
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      "code" in error &&
+      (error as NodeJS.ErrnoException).code === "ENOENT"
+    )
+      return false;
+    throw error;
+  }
+}