infinity-harness 2.6.6 → 2.8.0

package/src/daemon/worker.ts

@@ -0,0 +1,239 @@
+/**
+ * infinity-harness — daemon/worker.ts
+ *
+ * One AgentSession: create → prompt → settle → dispose, plus the
+ * events->TurnResult adapter. prompt() returns void in the SDK, so every
+ * turn field (servedModel, usage, tools, summary, contextRatio, compacted)
+ * comes via subscribe().
+ *
+ * v2.7's WorkerSession.prompt returned TurnResult; the SDK's prompt returns void.
+ * This file rebuilds the same shape by accumulating events.
+ */
+
+// Usage type is from pi session — use a loose shape to avoid hard dep on pi-ai path
+type Usage = { input?: number; output?: number; inputTokens?: number; outputTokens?: number; cacheRead?: number; cacheWrite?: number; cost?: number };
+
+export type TurnResult = {
+  summary: string;
+  tools: Array<{ name: string; ok: boolean }>;
+  usage: { input: number; output: number; cacheRead?: number; cacheWrite?: number; cost?: number };
+  contextRatio: number | null;
+  servedModel: string | null;
+  askedModel: string;
+  compacted: boolean;
+  aborted: boolean;
+  error: string | null;
+  modelFallbackMessage?: string | null;
+};
+
+export type WorkerEvents = {
+  onMessageStart?: (ev: unknown) => void;
+  onMessageUpdate?: (ev: unknown) => void;
+  onMessageEnd?: (ev: unknown) => void;
+  onToolStart?: (ev: unknown) => void;
+  onToolEnd?: (ev: unknown) => void;
+  onCompactionStart?: (ev: unknown) => void;
+};
+
+export type CreateWorkerOpts = {
+  cwd: string;
+  agentDir?: string;
+  modelSpec: { provider: string; id: string; thinkingLevel?: string };
+  askedModel: string;
+  sessionManagerDir?: string;
+  customTools?: unknown[];
+  thinkingLevel?: string;
+  resourceLoader?: unknown;
+  runId?: string;
+  unitKey?: string;
+  isolationBypassForTest?: boolean;
+};
+
+export type PromptOpts = {
+  text: string;
+  timeoutMs?: number;
+};
+
+/**
+ * Create one SDK AgentSession with harness-free loader + customTools.
+ * Returns session + unsubscribe + dispose handles.
+ */
+export async function createWorker(opts: CreateWorkerOpts): Promise<{
+  session: unknown;
+  unsubscribe: () => void;
+  dispose: () => void;
+  modelFallbackMessage?: string | null;
+  events: { servedModel: string | null; usage: Usage | null; tools: TurnResult["tools"]; summary: string; compacted: boolean };
+}> {
+  const mod = await import("@earendil-works/pi-coding-agent");
+  const { createAgentSession, ModelRuntime, SessionManager, DefaultResourceLoader, SettingsManager } = mod as unknown as {
+    createAgentSession: (opts: unknown) => Promise<{ session: unknown; modelFallbackMessage?: string | null; extensionsResult?: unknown }>;
+    ModelRuntime: { create: () => Promise<{ getModel: (p: string, id: string) => unknown; hasConfiguredAuth: (p: string) => boolean; checkAuth: (p: string) => Promise<unknown> }> };
+    SessionManager: { create: (cwd: string, dir?: string) => unknown; inMemory: (cwd: string) => unknown };
+    DefaultResourceLoader: new (opts: unknown) => { reload: () => Promise<void> };
+    SettingsManager: { create: (cwd: string, agentDir?: string) => unknown };
+  };
+
+  const runtime = await ModelRuntime.create();
+  const model = runtime.getModel(opts.modelSpec.provider, opts.modelSpec.id);
+  if (!model) throw new Error(`unknown model ${opts.modelSpec.provider}/${opts.modelSpec.id}`);
+
+  let loader: unknown = opts.resourceLoader;
+  if (!loader && !opts.isolationBypassForTest) {
+    const sm = SettingsManager.create(opts.cwd, opts.agentDir);
+    const l = new DefaultResourceLoader({
+      cwd: opts.cwd,
+      agentDir: opts.agentDir ?? "",
+      settingsManager: sm,
+      noExtensions: true,
+      noSkills: true,
+      noPromptTemplates: true,
+      noThemes: true,
+      noContextFiles: true,
+    } as unknown as ConstructorParameters<typeof DefaultResourceLoader>[0]);
+    await l.reload();
+    loader = l;
+  }
+
+  // Verify isolation: if loader discovery includes harness, fail fast (unless bypassed for test).
+  if (!opts.isolationBypassForTest && loader && typeof (loader as { getExtensions?: () => unknown }).getExtensions === "function") {
+    try {
+      const ext = (loader as { getExtensions: () => { extensions?: Array<{ id?: string }> } }).getExtensions();
+      const found = (ext?.extensions ?? []).filter(e => String(e?.id ?? "").includes("infinity-harness"));
+      if (found.length) throw new Error(`isolation violated: loader has ${found.length} harness extension(s)`);
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("isolation violated")) throw e;
+    }
+  }
+
+  const sessionManager = opts.sessionManagerDir
+    ? SessionManager.create(opts.cwd, opts.sessionManagerDir)
+    : SessionManager.inMemory(opts.cwd);
+
+  const thinkingLevel = (opts.thinkingLevel ?? opts.modelSpec.thinkingLevel ?? "medium") as unknown as string;
+
+  const agentTools = opts.customTools as unknown as import("@earendil-works/pi-coding-agent").ToolDefinition[] | undefined;
+
+  const created = await createAgentSession({
+    model: model as never,
+    modelRuntime: runtime as never,
+    cwd: opts.cwd,
+    thinkingLevel: thinkingLevel as never,
+    resourceLoader: loader as never,
+    customTools: agentTools as never,
+    sessionManager: sessionManager as never,
+  } as never);
+
+  const session = created.session as {
+    subscribe: (fn: (ev: { type: string; [k: string]: unknown }) => void) => () => void;
+    prompt: (text: string, opts?: unknown) => Promise<void>;
+    steer: (text: string) => Promise<void>;
+    dispose: () => void;
+    abort?: () => void;
+    model?: { provider?: string; id?: string };
+  };
+
+  if (created.modelFallbackMessage) throw new Error(`modelFallbackMessage: ${created.modelFallbackMessage}`);
+
+  const state = { servedModel: null as string | null, usage: null as Usage | null, tools: [] as TurnResult["tools"], summary: "", compacted: false };
+
+  const unsubscribe = session.subscribe((ev: { type: string; [k: string]: unknown }) => {
+    if (ev.type === "message_start") {
+      // message_start carries provider/model in some SDK versions
+      const prov = (ev as { provider?: string }).provider ?? (ev as { model?: { provider?: string } }).model?.provider;
+      const mid = (ev as { modelId?: string }).modelId ?? (ev as { model?: { id?: string } }).model?.id;
+      if (prov || mid) state.servedModel = `${prov ?? "?"}:${mid ?? "?"}`;
+    } else if (ev.type === "message_end") {
+      // usage is cumulative per session
+      const usage = (ev as { usage?: Usage }).usage;
+      if (usage) state.usage = usage as Usage;
+      const text = (ev as { content?: unknown }).content ?? (ev as { text?: string }).text;
+      if (typeof text === "string" && text) state.summary = text;
+      else if (Array.isArray((ev as { content?: unknown }).content)) {
+        const c = (ev as { content?: unknown }).content as Array<{ type?: string; text?: string }>;
+        const t = c.filter(x => x?.type === "text").map(x => x.text ?? "").join("\n");
+        if (t) state.summary = t;
+      }
+    } else if (ev.type === "tool_execution_start" || ev.type === "tool_execution_end") {
+      const name = String((ev as { toolName?: string }).toolName ?? (ev as { name?: string }).name ?? "tool");
+      const ok = ev.type === "tool_execution_end" ? ((ev as { ok?: boolean }).ok ?? true) : true;
+      // dedupe: keep last ok per name per end event
+      if (ev.type === "tool_execution_end") state.tools.push({ name, ok: Boolean(ok) });
+      else if (ev.type === "tool_execution_start") state.tools.push({ name, ok: true });
+    } else if (ev.type === "compaction_start") {
+      state.compacted = true;
+    } else if (ev.type === "entry_appended") {
+      // session entries include model_change and compaction; capture compaction usage
+      const entry = (ev as { entry?: { type?: string; usage?: Usage } }).entry;
+      if (entry?.type === "compaction" && entry.usage) state.compacted = true;
+    }
+  });
+
+  return {
+    session,
+    unsubscribe,
+    dispose: () => { try { unsubscribe(); } catch {} try { session.dispose(); } catch {} },
+    modelFallbackMessage: created.modelFallbackMessage ?? null,
+    events: state,
+  };
+}
+
+export async function promptWorker(
+  worker: { session: { prompt: (t: string, o?: unknown) => Promise<void> }; events: { servedModel: string | null; usage: Usage | null; tools: TurnResult["tools"]; summary: string; compacted: boolean } },
+  opts: PromptOpts,
+): Promise<TurnResult> {
+  // We need the askedModel — fall back to events.servedModel if not known.
+  const askedModel = "asked";
+  const startedUsage = worker.events.usage;
+  try {
+    const timeoutMs = opts.timeoutMs ?? 30 * 60 * 1000;
+    let settled = false;
+    const timer = timeoutMs > 0 ? setTimeout(() => { if (!settled) try { (worker.session as { abort?: () => void }).abort?.(); } catch {} }, timeoutMs) : null;
+    try {
+      await worker.session.prompt(opts.text);
+      settled = true;
+    } finally {
+      if (timer) clearTimeout(timer);
+      settled = true;
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    // CredentialSynchronizationError is handled by caller; bubble it.
+    if (msg.includes("CredentialSynchronizationError") || (e as { name?: string })?.name === "CredentialSynchronizationError") throw e;
+    return {
+      summary: worker.events.summary,
+      tools: worker.events.tools,
+      usage: toUsageTotals(worker.events.usage, startedUsage),
+      contextRatio: null,
+      servedModel: worker.events.servedModel,
+      askedModel,
+      compacted: worker.events.compacted,
+      aborted: msg.toLowerCase().includes("abort"),
+      error: msg,
+    };
+  }
+  return {
+    summary: worker.events.summary,
+    tools: worker.events.tools,
+    usage: toUsageTotals(worker.events.usage, startedUsage),
+    contextRatio: null,
+    servedModel: worker.events.servedModel,
+    askedModel,
+    compacted: worker.events.compacted,
+    aborted: false,
+    error: null,
+  };
+}
+
+function toUsageTotals(cur: Usage | null, _prev: Usage | null): { input: number; output: number; cacheRead?: number; cacheWrite?: number; cost?: number } {
+  if (!cur) return { input: 0, output: 0 };
+  // pi usage is cumulative per session; the last reading IS the total.
+  const input = typeof (cur as { input?: number }).input === "number" ? (cur as { input: number }).input
+    : typeof (cur as { inputTokens?: number }).inputTokens === "number" ? (cur as unknown as { inputTokens: number }).inputTokens : 0;
+  const output = typeof (cur as { output?: number }).output === "number" ? (cur as { output: number }).output
+    : typeof (cur as { outputTokens?: number }).outputTokens === "number" ? (cur as unknown as { outputTokens: number }).outputTokens : 0;
+  const cacheRead = (cur as { cacheRead?: number }).cacheRead ?? 0;
+  const cacheWrite = (cur as { cacheWrite?: number }).cacheWrite ?? 0;
+  const cost = (cur as { cost?: number }).cost ?? 0;
+  return { input, output, cacheRead, cacheWrite, cost };
+}

package/src/daemon/worktree.ts

@@ -0,0 +1,95 @@
+/**
+ * infinity-harness — daemon/worktree.ts
+ *
+ * Git worktree per concurrent worker. Gate in worktree, merge lock, unlock.
+ *
+ * v3.0 is sequential (maxWorkers:1) — this file is the isolation that will be
+ * used when we lift that. Kept isolated in its own module so it cannot leak
+ * into the single-owner path prematurely.
+ */
+
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { worktreePath, worktreesDir } from "../core/paths.ts";
+import { run } from "../core/exec.ts";
+import { ensureDir } from "../core/fsx.ts";
+
+export async function isWorktreeSupported(targetDir: string): Promise<boolean> {
+  const r = await run("git rev-parse --is-inside-work-tree", { cwd: targetDir, timeoutMs: 10_000 });
+  return r.ok && r.stdout.trim() === "true";
+}
+
+export async function createWorktree(targetDir: string, branch: string): Promise<{ path: string; error: string | null }> {
+  if (!await isWorktreeSupported(targetDir)) return { path: "", error: "not a git repo — cannot create worktree" };
+  const worktree = worktreePath(targetDir, branch);
+  if (existsSync(worktree)) return { path: worktree, error: null };
+  try { ensureDir(worktreesDir(targetDir)); } catch {}
+  // Safe to create on current HEAD: `git worktree add <path>` with no branch creates detached worktree
+  const r = await run(`git worktree add --detach "${worktree.replace(/"/g, '\\"')}"`, { cwd: targetDir, timeoutMs: 30_000 });
+  if (!r.ok) return { path: "", error: (r.stderr || r.stdout || r.spawnError || `git worktree add exited ${r.code}`).slice(0, 400) };
+  return { path: worktree, error: null };
+}
+
+export async function removeWorktree(targetDir: string, branch: string): Promise<{ ok: boolean; error: string | null }> {
+  const worktree = worktreePath(targetDir, branch);
+  if (!existsSync(worktree)) return { ok: true, error: null };
+  const r = await run(`git worktree remove --force "${worktree.replace(/"/g, '\\"')}"`, { cwd: targetDir, timeoutMs: 30_000 });
+  if (!r.ok && !r.stderr?.includes("not a valid path")) return { ok: false, error: (r.stderr || r.stdout || r.spawnError || `exit ${r.code}`).slice(0,400) };
+  // Also prune any stale branch/worktree registration
+  await run("git worktree prune", { cwd: targetDir, timeoutMs: 15_000 });
+  return { ok: true, error: null };
+}
+
+export async function removeAllWorktrees(targetDir: string): Promise<void> {
+  await run("git worktree prune", { cwd: targetDir, timeoutMs: 15_000 });
+  // Best-effort remove each directory under harness/worktrees
+  const root = worktreesDir(targetDir);
+  if (!existsSync(root)) return;
+  let entries: string[] = [];
+  try { const { readdirSync } = await import("node:fs"); entries = readdirSync(root); } catch {}
+  for (const e of entries) {
+    await removeWorktree(targetDir, e);
+  }
+}
+
+export async function gateInWorktree(targetDir: string, worktree: string, phase: string): Promise<{ pass: boolean; reason?: string }> {
+  const { runChecks } = await import("../core/gates.ts");
+  const g = await runChecks(worktree, phase as never, { record: false });
+  if (g.overall) return { pass: true };
+  return { pass: false, reason: g.failures.join(", ") };
+}
+
+export async function mergeWorktreeBranch(targetDir: string, branch: string, worktree: string, gatePhase?: string): Promise<{ ok: boolean; conflict?: boolean; reason?: string }> {
+  // We use a harness/<unit> branch name when creating the worktree. Merge with `git merge`.
+  const branchName = `harness/${branch}`;
+  // Ensure branch exists (worktree add --detach doesn't create one). Create branch from worktree HEAD.
+  const currentHead = (await run(`git -C "${worktree.replace(/"/g,'\\"')}" rev-parse HEAD`, { cwd: targetDir, timeoutMs: 10_000 })).stdout?.trim() ?? null;
+  if (currentHead) {
+    const create = await run(`git branch "${branchName}" "${currentHead}"`, { cwd: targetDir, timeoutMs: 15_000 });
+    // exists is ok — we will merge the branch if already there.
+    if (!create.ok && !(create.stderr||"").includes("already exists")) {
+      // best-effort: continue to merge attempt
+    }
+  }
+  const merge = await run(`git merge --no-ff --no-edit "${branchName}"`, { cwd: targetDir, timeoutMs: 30_000 });
+  if (merge.ok) {
+    await run(`git branch -D "${branchName}"`, { cwd: targetDir, timeoutMs: 10_000 });
+    const { runChecks: _runChecks } = await import("../core/gates.ts");
+    const { loadConfig } = await import("../core/config.ts");
+    const phase = gatePhase ?? ((loadConfig(targetDir).config?.currentPhase as unknown as string) ?? "build");
+    const post = await _runChecks(targetDir, phase as never, { record: false });
+    if (!post.overall) {
+      await run("git reset --hard HEAD~1", { cwd: targetDir, timeoutMs: 15_000 }).catch(()=>null as never);
+      return { ok: false, conflict: false, reason: `post-merge gate FAIL: ${post.failures.join(", ")}` };
+    }
+    return { ok: true };
+  }
+  const out = (merge.stdout ?? "") + "\n" + (merge.stderr ?? "");
+  const conflict = /conflict/i.test(out);
+  if (conflict) {
+    await run("git merge --abort", { cwd: targetDir, timeoutMs: 10_000 }).catch(()=>null as never);
+    return { ok: false, conflict: true, reason: out.slice(0,500) };
+  }
+  await run("git merge --abort", { cwd: targetDir, timeoutMs: 10_000 }).catch(()=>null as never);
+  return { ok: false, conflict: false, reason: out.slice(0,500) };
+}