@bjoernrochel/sevro 0.1.0-rc.2 → 0.1.0-rc.21

package/src/hosts/codex-configuration.ts

@@ -1,3 +1,5 @@
+import type { Stats } from "node:fs";
+import { isRecord } from "../value-guards";
 import { lstat, readFile, realpath, stat } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, sep } from "node:path";
 import { parse } from "smol-toml";
@@ -9,8 +11,8 @@ export async function configurationRoot(root: string): Promise<string> {
     if (!(await stat(canonical)).isDirectory())
       throw new Error("not a directory");
     return canonical;
-  } catch {
-    throw new Error(`configuration root is unreadable: ${root}`);
+  } catch (cause) {
+    throw new Error(`configuration root is unreadable: ${root}`, { cause });
   }
 }
 
@@ -34,6 +36,15 @@ export async function codexAgentConcurrency(
   root: string,
 ): Promise<number | null> {
   const configPath = join(root, ".codex", "config.toml");
+  const source = await readConfiguration(root, configPath);
+  if (source === null) return null;
+  return parseAgentConcurrency(source, configPath);
+}
+
+async function readConfiguration(
+  root: string,
+  configPath: string,
+): Promise<string | null> {
   let source: string;
   let declared = false;
   try {
@@ -41,17 +52,7 @@ export async function codexAgentConcurrency(
     const info = await lstat(configPath);
     declared = true;
     const canonical = await realpath(configPath);
-    const location = relative(root, canonical);
-    if (
-      !info.isFile() ||
-      info.size > 64 * 1024 ||
-      location === ".." ||
-      location.startsWith(`..${sep}`) ||
-      isAbsolute(location)
-    )
-      throw new Error(
-        "configuration must be a contained regular file up to 64 KiB",
-      );
+    validateConfigurationFile(info, relative(root, canonical));
     source = await readFile(configPath, "utf8");
   } catch (error) {
     if (!declared && (error as NodeJS.ErrnoException).code === "ENOENT")
@@ -60,18 +61,30 @@ export async function codexAgentConcurrency(
       cause: error,
     });
   }
+  return source;
+}
+
+function parseAgentConcurrency(
+  source: string,
+  configPath: string,
+): number | null {
   let config: Record<string, unknown>;
   try {
     config = parse(source, { integersAsBigInt: true });
-  } catch {
-    throw new Error(`Invalid Codex configuration: ${configPath}`);
+  } catch (cause) {
+    throw new Error(`Invalid Codex configuration: ${configPath}`, { cause });
   }
   const agents = config.agents;
   if (agents === undefined) return null;
-  if (!agents || typeof agents !== "object" || Array.isArray(agents))
+  if (!isRecord(agents))
     throw new Error(`Expected an agents table in ${configPath}`);
-  const limit = (agents as Record<string, unknown>)
-    .max_concurrent_threads_per_session;
+  return concurrencyLimit(
+    agents.max_concurrent_threads_per_session,
+    configPath,
+  );
+}
+
+function concurrencyLimit(limit: unknown, configPath: string): number | null {
   if (limit === undefined) return null;
   if (
     typeof limit !== "bigint" ||
@@ -83,3 +96,16 @@ export async function codexAgentConcurrency(
     );
   return Number(limit);
 }
+
+function validateConfigurationFile(info: Stats, location: string): void {
+  if (!info.isFile() || info.size > 64 * 1024 || escapedRoot(location))
+    throw new Error(
+      "configuration must be a contained regular file up to 64 KiB",
+    );
+}
+
+function escapedRoot(location: string): boolean {
+  return (
+    location === ".." || location.startsWith(`..${sep}`) || isAbsolute(location)
+  );
+}

package/src/hosts/codex-events.ts

@@ -1,32 +1,89 @@
+import { isRecord } from "../value-guards";
 const MAX_EVENT_STREAM_BYTES = 8 * 1024 * 1024;
 
 export class CodexEventError extends Error {
-  constructor(message: string) {
-    super(message);
+  constructor(message: string, options?: ErrorOptions) {
+    super(message, options);
     this.name = "CodexEventError";
   }
 }
 
-function record(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
 function usage(
   value: unknown,
 ): { inputTokens: number; outputTokens: number } | null {
-  if (!record(value)) return null;
+  if (!isRecord(value)) return null;
   const input = value.input_tokens;
   const output = value.output_tokens;
+  if (!nonnegativeInteger(input) || !nonnegativeInteger(output)) return null;
+  return { inputTokens: input, outputTokens: output };
+}
+
+function nonnegativeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+interface TurnState {
+  threadId: string | null;
+  completed: boolean;
+  failed: boolean;
+  finalMessage: string | null;
+  tokenUsage: ReturnType<typeof usage>;
+}
+
+function parseEvent(line: string): Record<string, unknown> {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch (cause) {
+    throw new CodexEventError("Codex event stream contains invalid JSONL", {
+      cause,
+    });
+  }
+  if (!isRecord(parsed) || typeof parsed.type !== "string")
+    throw new CodexEventError("Codex event stream contains an invalid event");
+  return parsed;
+}
+
+function startThread(state: TurnState, event: Record<string, unknown>): void {
   if (
-    typeof input !== "number" ||
-    !Number.isSafeInteger(input) ||
-    input < 0 ||
-    typeof output !== "number" ||
-    !Number.isSafeInteger(output) ||
-    output < 0
+    state.threadId !== null ||
+    typeof event.thread_id !== "string" ||
+    !event.thread_id
   )
-    return null;
-  return { inputTokens: input, outputTokens: output };
+    throw new CodexEventError("Codex event stream has an invalid thread start");
+  state.threadId = event.thread_id;
+}
+
+function completeTurn(state: TurnState, event: Record<string, unknown>): void {
+  if (!state.threadId || state.completed || state.failed)
+    throw new CodexEventError(
+      "Codex event stream has an invalid turn completion",
+    );
+  state.completed = true;
+  state.tokenUsage = usage(event.usage);
+}
+
+function completeItem(state: TurnState, item: unknown): void {
+  if (!isRecord(item) || item.type !== "agent_message" || state.completed)
+    return;
+  state.finalMessage = typeof item.text === "string" ? item.text : null;
+}
+
+function applyEvent(state: TurnState, event: Record<string, unknown>): void {
+  switch (event.type) {
+    case "thread.started":
+      startThread(state, event);
+      break;
+    case "item.completed":
+      completeItem(state, event.item);
+      break;
+    case "turn.completed":
+      completeTurn(state, event);
+      break;
+    case "turn.failed":
+      state.failed = true;
+      break;
+  }
 }
 
 export interface CodexEventSummary {
@@ -45,58 +102,38 @@ export function summarizeCodexEvents(
 ): CodexEventSummary {
   if (Buffer.byteLength(stream, "utf8") > MAX_EVENT_STREAM_BYTES)
     throw new CodexEventError("Codex event stream exceeds 8 MiB");
-  let threadId: string | null = null;
-  let completed = false;
-  let failed = false;
-  let finalMessage: string | null = null;
-  let tokenUsage: ReturnType<typeof usage> = null;
-  let usageComplete = false;
+  const state: TurnState = {
+    threadId: null,
+    completed: false,
+    failed: false,
+    finalMessage: null,
+    tokenUsage: null,
+  };
   for (const line of stream.split("\n")) {
     if (!line.trim()) continue;
-    let parsed: unknown;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      throw new CodexEventError("Codex event stream contains invalid JSONL");
-    }
-    if (!record(parsed) || typeof parsed.type !== "string")
-      throw new CodexEventError("Codex event stream contains an invalid event");
-    if (parsed.type === "thread.started") {
-      if (
-        threadId !== null ||
-        typeof parsed.thread_id !== "string" ||
-        !parsed.thread_id
-      )
-        throw new CodexEventError(
-          "Codex event stream has an invalid thread start",
-        );
-      threadId = parsed.thread_id;
-    }
-    if (parsed.type === "item.completed" && record(parsed.item)) {
-      if (parsed.item.type === "agent_message" && !completed) {
-        finalMessage =
-          typeof parsed.item.text === "string" ? parsed.item.text : null;
-      }
-    }
-    if (parsed.type === "turn.completed") {
-      if (!threadId || completed || failed)
-        throw new CodexEventError(
-          "Codex event stream has an invalid turn completion",
-        );
-      completed = true;
-      usageComplete = usage(parsed.usage) !== null;
-      tokenUsage = usage(parsed.usage);
-    }
-    if (parsed.type === "turn.failed") failed = true;
+    applyEvent(state, parseEvent(line));
   }
+  return summarizeTurn(state, exitCode);
+}
+
+function summarizeTurn(state: TurnState, exitCode: number): CodexEventSummary {
+  const { threadId, completed, failed, finalMessage, tokenUsage } = state;
   if (!threadId)
     throw new CodexEventError("Codex event stream has no thread start");
+  const complete = exitCode === 0 && completed && !failed;
   return {
     threadId,
-    complete: exitCode === 0 && completed && !failed,
+    complete,
     finalMessage,
-    inputTokens: tokenUsage?.inputTokens ?? null,
-    outputTokens: tokenUsage?.outputTokens ?? null,
-    usageComplete: exitCode === 0 && completed && !failed && usageComplete,
+    ...summarizeUsage(tokenUsage, complete),
   };
 }
+
+function summarizeUsage(
+  tokenUsage: ReturnType<typeof usage>,
+  complete: boolean,
+) {
+  if (tokenUsage === null)
+    return { inputTokens: null, outputTokens: null, usageComplete: false };
+  return { ...tokenUsage, usageComplete: complete };
+}