openhermes 4.12.1 → 4.13.0

package/harness/lib/background/background.test.ts

@@ -1,216 +0,0 @@
-import { describe, it, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { BackgroundManager } from "./manager.ts";
-import type { BackgroundTaskStatus } from "./interfaces.ts";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-/**
- * Poll check() until the task reaches one of the given statuses, or until
- * a generous timeout elapses (2.5 s).
- */
-async function waitForStatus(
-  manager: BackgroundManager,
-  id: string,
-  ...expected: BackgroundTaskStatus[]
-): Promise<void> {
-  for (let i = 0; i < 50; i++) {
-    const task = manager.check(id);
-    if (task && expected.includes(task.status)) return;
-    await delay(50);
-  }
-  const task = manager.check(id);
-  const actual = task?.status ?? "(not found)";
-  throw new Error(
-    `Timed out waiting for status [${expected.join("/")}], got "${actual}"`,
-  );
-}
-
-// Windows detection — some assertions differ per platform
-const IS_WIN = process.platform === "win32";
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("BackgroundManager", () => {
-  afterEach(() => {
-    BackgroundManager.resetInstance();
-  });
-
-  // ---- 1: run() returns ID immediately ----------------------------------
-
-  it("run() returns a task ID immediately", () => {
-    const mgr = BackgroundManager.getInstance();
-    const id = mgr.run({ command: IS_WIN ? "echo" : "echo", args: ["hello"] });
-    assert.ok(typeof id === "string");
-    assert.ok(id.length > 0, "id must not be empty");
-  });
-
-  // ---- 2: check() shows pending → running → completed -------------------
-
-  it("check() transitions pending -> running -> completed", async () => {
-    const mgr = BackgroundManager.getInstance();
-    const id = mgr.run({ command: IS_WIN ? "echo" : "echo", args: ["hello"] });
-
-    // Immediately after run() the task should be "pending"
-    // (spawn is deferred via setImmediate)
-    const initial = mgr.check(id);
-    assert.ok(initial, "task must exist immediately");
-    assert.equal(initial!.status, "pending");
-
-    // Wait for it to complete
-    await waitForStatus(mgr, id, "completed");
-    const done = mgr.check(id);
-    assert.equal(done!.exitCode, 0);
-  });
-
-  it("resetInstance returns a fresh manager with cleared state", async () => {
-    const mgr = BackgroundManager.getInstance();
-    const id = mgr.run({
-      command: IS_WIN ? "powershell.exe" : "sleep",
-      args: IS_WIN
-        ? ["-NoProfile", "-Command", "Start-Sleep -Seconds 30"]
-        : ["30"],
-      timeout: 0,
-    });
-
-    await waitForStatus(mgr, id, "running");
-
-    BackgroundManager.resetInstance();
-
-    const fresh = BackgroundManager.getInstance();
-    assert.notEqual(fresh, mgr);
-    assert.equal(fresh.list().length, 0);
-  });
-
-  // ---- 3: capture stdout -------------------------------------------------
-
-  it("captures stdout from a simple command", async () => {
-    const mgr = BackgroundManager.getInstance();
-    const id = mgr.run({
-      command: IS_WIN ? "echo" : "echo",
-      args: ["hello-background"],
-    });
-
-    await waitForStatus(mgr, id, "completed");
-    const task = mgr.check(id);
-    assert.ok(task, "task must exist");
-    assert.match(task!.output, /hello-background/);
-  });
-
-  // ---- 4: failed command (non-zero exit) ---------------------------------
-
-  it("detects a failed command (non-zero exit)", async () => {
-    const mgr = BackgroundManager.getInstance();
-    const id = mgr.run({
-      command: IS_WIN ? "cmd.exe" : "bash",
-      args: IS_WIN ? ["/c", "exit", "1"] : ["-c", "exit 1"],
-    });
-
-    await waitForStatus(mgr, id, "failed");
-    const task = mgr.check(id);
-    assert.ok(task);
-    assert.equal(task!.exitCode, 1);
-    assert.equal(task!.status, "failed");
-  });
-
-  // ---- 5: timeout enforcement --------------------------------------------
-
-  it("enforces timeout and marks task as timed_out", async () => {
-    const mgr = BackgroundManager.getInstance();
-
-    // Use a long-running command with a very short timeout (100 ms)
-    const id = mgr.run({
-      command: IS_WIN ? "powershell.exe" : "sleep",
-      args: IS_WIN
-        ? ["-NoProfile", "-Command", "Start-Sleep -Seconds 30"]
-        : ["30"],
-      timeout: 100,
-    });
-
-    await waitForStatus(mgr, id, "timed_out");
-    const task = mgr.check(id);
-    assert.ok(task);
-    assert.equal(task!.status, "timed_out");
-  });
-
-  // ---- 6: kill() marks as cancelled --------------------------------------
-
-  it("kill() marks a running task as cancelled", async () => {
-    const mgr = BackgroundManager.getInstance();
-
-    const id = mgr.run({
-      command: IS_WIN ? "powershell.exe" : "sleep",
-      args: IS_WIN
-        ? ["-NoProfile", "-Command", "Start-Sleep -Seconds 30"]
-        : ["30"],
-      timeout: 0, // no timeout
-    });
-
-    // Wait for the task to enter "running"
-    await waitForStatus(mgr, id, "running");
-
-    // Kill it
-    const killed = mgr.kill(id);
-    assert.ok(killed, "kill() must return true");
-
-    const task = mgr.check(id);
-    assert.ok(task);
-    assert.equal(task!.status, "cancelled");
-  });
-
-  // ---- 7: list() returns all tasks ---------------------------------------
-
-  it("list() returns all tracked tasks", async () => {
-    const mgr = BackgroundManager.getInstance();
-    const id1 = mgr.run({ command: IS_WIN ? "echo" : "echo", args: ["a"] });
-    const id2 = mgr.run({ command: IS_WIN ? "echo" : "echo", args: ["b"] });
-
-    const tasks = mgr.list();
-    const ids = tasks.map((t) => t.id);
-    assert.ok(ids.includes(id1), "list must contain first task");
-    assert.ok(ids.includes(id2), "list must contain second task");
-  });
-
-  // ---- 8: kill() on already-terminal task returns false ------------------
-
-  it("kill() returns false for already-completed task", async () => {
-    const mgr = BackgroundManager.getInstance();
-    const id = mgr.run({ command: IS_WIN ? "echo" : "echo", args: ["quick"] });
-
-    await waitForStatus(mgr, id, "completed");
-    const result = mgr.kill(id);
-    assert.equal(result, false, "kill() must return false on complete task");
-  });
-
-  // ---- 9: check() returns undefined for unknown ID -----------------------
-
-  it("check() returns undefined for unknown task ID", () => {
-    const mgr = BackgroundManager.getInstance();
-    const result = mgr.check("nonexistent-id");
-    assert.equal(result, undefined);
-  });
-
-  // ---- 10: error output captured on command-not-found --------------------
-
-  it("captures error output when command does not exist", async () => {
-    const mgr = BackgroundManager.getInstance();
-    const id = mgr.run({ command: "this-command-does-not-exist-hopefully" });
-
-    await waitForStatus(mgr, id, "failed");
-    const task = mgr.check(id);
-    assert.ok(task);
-    // On Windows cmd.exe will emit an error; on Unix spawn error will fire
-    assert.ok(
-      task!.errorOutput.length > 0 || task!.output.length > 0,
-      "should have some error output",
-    );
-  });
-});

package/harness/lib/background/index.ts

@@ -1,7 +0,0 @@
-export type {
-  BackgroundTask,
-  BackgroundTaskStatus,
-  BackgroundRunOptions,
-} from "./interfaces.ts";
-
-export { BackgroundManager } from "./manager.ts";

package/harness/lib/background/interfaces.ts

@@ -1,31 +0,0 @@
-export interface BackgroundTask {
-  id: string;
-  command: string;
-  args: string[];
-  cwd: string;
-  status: BackgroundTaskStatus;
-  output: string;
-  errorOutput: string;
-  exitCode: number | null;
-  startTime: number;
-  endTime: number | null;
-  timeout: number;       // ms, 0 = no timeout
-  label?: string;
-}
-
-export type BackgroundTaskStatus =
-  | "pending"
-  | "running"
-  | "completed"
-  | "failed"
-  | "timed_out"
-  | "cancelled";
-
-export interface BackgroundRunOptions {
-  command: string;
-  args?: string[];
-  cwd?: string;
-  timeout?: number;      // ms, default 30000
-  label?: string;
-  env?: Record<string, string>;
-}

package/harness/lib/background/manager.ts

@@ -1,320 +0,0 @@
-import { spawn, exec, type ChildProcess } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import type {
-  BackgroundTask,
-  BackgroundTaskStatus,
-  BackgroundRunOptions,
-} from "./interfaces.ts";
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const CLEANUP_INTERVAL_MS = 60_000; // Check for stale tasks every 60s
-const TASK_MAX_AGE_MS = 5 * 60 * 1000; // 5 minutes
-
-// ---------------------------------------------------------------------------
-// Internal entry
-// ---------------------------------------------------------------------------
-
-interface TaskEntry {
-  task: BackgroundTask;
-  process: ChildProcess | null;
-  timeoutId?: ReturnType<typeof setTimeout>;
-}
-
-// ---------------------------------------------------------------------------
-// Manager
-// ---------------------------------------------------------------------------
-
-export class BackgroundManager {
-  private static instance: BackgroundManager | null = null;
-  private tasks = new Map<string, TaskEntry>();
-  private cleanupTimer: ReturnType<typeof setInterval> | null = null;
-
-  private constructor() {
-    this.startCleanup();
-  }
-
-  // -----------------------------------------------------------------------
-  // Singleton
-  // -----------------------------------------------------------------------
-
-  static getInstance(): BackgroundManager {
-    if (!BackgroundManager.instance) {
-      BackgroundManager.instance = new BackgroundManager();
-    }
-    return BackgroundManager.instance;
-  }
-
-  /** Reset singleton — used in tests to get a clean slate. */
-  static resetInstance(): void {
-    const inst = BackgroundManager.instance;
-    if (inst) {
-      inst.destroy();
-      BackgroundManager.instance = null;
-    }
-  }
-
-  // -----------------------------------------------------------------------
-  // Public API
-  // -----------------------------------------------------------------------
-
-  /**
-   * Spawn a background process and return its task ID immediately.
-   * The task status starts as "pending" and transitions to "running" on
-   * the next event-loop tick when the process actually spawns.
-   */
-  run(options: BackgroundRunOptions): string {
-    const id = randomUUID();
-    const cwd = options.cwd ?? process.cwd();
-    const args = options.args ?? [];
-    const timeout = options.timeout ?? 30_000;
-
-    const task: BackgroundTask = {
-      id,
-      command: options.command,
-      args,
-      cwd,
-      status: "pending",
-      output: "",
-      errorOutput: "",
-      exitCode: null,
-      startTime: Date.now(),
-      endTime: null,
-      timeout,
-      label: options.label,
-    };
-
-    const entry: TaskEntry = { task, process: null };
-    this.tasks.set(id, entry);
-
-    // Defer to next tick so callers can observe "pending" immediately
-    setImmediate(() => {
-      this.spawnTask(id, options, entry);
-    });
-
-    return id;
-  }
-
-  /** Return current state of a tracked task, or undefined if not found. */
-  check(id: string): BackgroundTask | undefined {
-    this.sweepStale();
-    return this.tasks.get(id)?.task;
-  }
-
-  /** Return all tracked tasks (including completed ones). */
-  list(): BackgroundTask[] {
-    this.sweepStale();
-    return Array.from(this.tasks.values()).map((e) => e.task);
-  }
-
-  /**
-   * Kill a running / pending task.
-   * Returns true if the task existed and was killable, false otherwise.
-   */
-  kill(id: string): boolean {
-    const entry = this.tasks.get(id);
-    if (!entry) return false;
-
-    const { task } = entry;
-    if (isTerminal(task.status)) return false;
-
-    this.killProcess(entry);
-    task.status = "cancelled";
-    task.endTime = Date.now();
-    this.clearTimeout(entry);
-    return true;
-  }
-
-  // -----------------------------------------------------------------------
-  // Lifecycle (test cleanup / singleton teardown)
-  // -----------------------------------------------------------------------
-
-  /** Shut down the manager — kill all processes, clear state, stop timers. */
-  destroy(): void {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-      this.cleanupTimer = null;
-    }
-    for (const [, entry] of this.tasks) {
-      if (!isTerminal(entry.task.status)) {
-        this.killProcess(entry);
-      }
-      this.clearTimeout(entry);
-    }
-    this.tasks.clear();
-  }
-
-  // -----------------------------------------------------------------------
-  // Internals
-  // -----------------------------------------------------------------------
-
-  private spawnTask(
-    id: string,
-    options: BackgroundRunOptions,
-    entry: TaskEntry,
-  ): void {
-    const { task } = entry;
-    const args = options.args ?? [];
-    const env = options.env;
-    const timeout = options.timeout ?? 30_000;
-
-    try {
-      const isWindows = process.platform === "win32";
-
-      // On Windows, wrap everything in cmd.exe /c so PATH and .exe
-      // resolution work the way users expect.
-      // Sanitize: strip shell metacharacters from the command to prevent
-      // command injection via LLM-generated command strings.
-      const command = isWindows ? "cmd.exe" : options.command;
-      const sanitizedCommand = isWindows
-        ? options.command.replace(/[&|;<>^%!]/g, "")
-        : options.command;
-      const sanitizedArgs = args.map((a) =>
-        a.replace(/[&|;<>^%!]/g, ""),
-      );
-      const commandArgs = isWindows
-        ? ["/d", "/c", sanitizedCommand, ...sanitizedArgs]
-        : args;
-
-      const child = spawn(command, commandArgs, {
-        cwd: task.cwd,
-        env: env ? { ...process.env, ...env } : undefined,
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-
-      entry.process = child;
-      task.status = "running";
-
-      child.stdout?.on("data", (data: Buffer) => {
-        task.output += data.toString();
-      });
-
-      child.stderr?.on("data", (data: Buffer) => {
-        task.errorOutput += data.toString();
-      });
-
-      child.on("error", (err: Error) => {
-        task.status = "failed";
-        task.errorOutput += `\n[spawn error] ${err.message}`;
-        task.endTime = Date.now();
-        this.clearTimeout(entry);
-      });
-
-      child.on("close", (code: number | null) => {
-        task.exitCode = code;
-        task.endTime = Date.now();
-        if (task.status === "running" || task.status === "pending") {
-          task.status = code === 0 ? "completed" : "failed";
-        }
-        this.clearTimeout(entry);
-      });
-
-      // Timeout enforcement
-      if (timeout > 0) {
-        entry.timeoutId = setTimeout(() => {
-          if (!isTerminal(task.status)) {
-            this.killProcess(entry);
-            task.status = "timed_out";
-            task.endTime = Date.now();
-          }
-        }, timeout);
-      }
-    } catch (err) {
-      task.status = "failed";
-      task.errorOutput = `[exception] ${String(err)}`;
-      task.endTime = Date.now();
-    }
-  }
-
-  private async killProcess(entry: TaskEntry): Promise<void> {
-    if (!entry.process) return;
-
-    if (process.platform === "win32") {
-      // Forceful tree-kill via taskkill (more reliable than SIGTERM on Windows)
-      try {
-        await new Promise<void>((resolve, reject) => {
-          exec(`taskkill /pid ${entry.process!.pid} /f /t`, (err) => {
-            if (err) reject(err);
-            else resolve();
-          });
-        });
-      } catch {
-        // taskkill failed — process may already be dead
-      }
-      // Also try SIGTERM as a graceful fallback
-      try {
-        entry.process.kill("SIGTERM");
-      } catch {
-        /* already dead */
-      }
-    } else {
-      try {
-        entry.process.kill("SIGTERM");
-      } catch {
-        /* already dead */
-      }
-    }
-  }
-
-  private clearTimeout(entry: TaskEntry): void {
-    if (entry.timeoutId !== undefined) {
-      clearTimeout(entry.timeoutId);
-      entry.timeoutId = undefined;
-    }
-  }
-
-  private startCleanup(): void {
-    this.cleanupTimer = setInterval(() => this.sweepStale(), CLEANUP_INTERVAL_MS);
-    this.cleanupTimer?.unref();
-  }
-
-  /**
-   * Remove stale tasks:
-   * - Completed/failed tasks older than TASK_MAX_AGE_MS
-   * - Zombie processes (status "running" but process handle is dead)
-   */
-  private sweepStale(): void {
-    const now = Date.now();
-    for (const [id, entry] of this.tasks) {
-      const { task } = entry;
-
-      // Completed/failed tasks older than threshold
-      if (task.endTime && now - task.endTime > TASK_MAX_AGE_MS) {
-        this.clearTimeout(entry);
-        this.tasks.delete(id);
-        continue;
-      }
-
-      // Check for zombie processes: status "running" but process has exited
-      // Use exitCode !== null as the reliable cross-platform check
-      if (task.status === "running" && entry.process) {
-        if (entry.process.exitCode !== null) {
-          // Process exited but the close event wasn't processed (zombie)
-          task.status = "failed";
-          task.endTime = Date.now();
-          this.tasks.delete(id);
-        }
-      } else if (task.status === "running" && !entry.process) {
-        // Process reference is gone but status not updated
-        task.status = "failed";
-        task.endTime = Date.now();
-        this.tasks.delete(id);
-      }
-    }
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function isTerminal(status: BackgroundTaskStatus): boolean {
-  return (
-    status === "completed" ||
-    status === "failed" ||
-    status === "timed_out" ||
-    status === "cancelled"
-  );
-}

package/harness/lib/hooks/builtins/error-recovery-hook.ts

@@ -1,107 +0,0 @@
-// ---------------------------------------------------------------------------
-// ErrorRecoveryHook — PostToolUse, priority=50, phase=LATE
-//
-// After sub-agent call, check if output indicates error.
-// Use the RecoveryHandler to match patterns and inject recovery actions.
-// ---------------------------------------------------------------------------
-
-import { HookPhase, HookResult } from "../types.ts";
-import type { HookContext, PostToolUseHook } from "../types.ts";
-import { RecoveryHandler } from "../../recovery/handler.ts";
-import type { ErrorContext } from "../../recovery/interfaces.ts";
-
-export const errorRecoveryHook: PostToolUseHook = {
-  metadata: {
-    name: "error-recovery",
-    priority: 50,
-    phase: HookPhase.LATE,
-    dependencies: [],
-    errorHandling: "isolate",
-  },
-
-  async execute(context: HookContext, output: string) {
-    // Check if the output looks like an error
-    const isErrorOutput = looksLikeError(output);
-    if (!isErrorOutput) {
-      return { result: HookResult.CONTINUE };
-    }
-
-    // Classify the error and get a recovery action
-    const handler = RecoveryHandler.getInstance();
-    const errorContext: ErrorContext = {
-      sessionId: context.sessionId,
-      error: new Error(output.slice(0, 500)), // Truncate for classification
-      attempt: context._recoveryAttempt ?? 0,
-      timestamp: Date.now(),
-      agent: context.agent,
-    };
-
-    const action = handler.handleError(errorContext);
-
-    // Build a recovery instruction based on the action
-    const recoveryInstruction = buildRecoveryInstruction(action);
-
-    return {
-      result: HookResult.INJECT,
-      modifiedOutput: output,
-      injectRecovery: recoveryInstruction,
-    };
-  },
-};
-
-/**
- * Heuristic check: does the output look like an error?
- * Looks for common error patterns in tool output.
- */
-function looksLikeError(output: string): boolean {
-  if (!output || output.length === 0) return false;
-
-  const errorPatterns = [
-    /error/i,
-    /exception/i,
-    /failed/i,
-    /failure/i,
-    /unable to/i,
-    /could not/i,
-    /not found/i,
-    /ECONNREFUSED/i,
-    /ETIMEDOUT/i,
-    /rate.?limited/i,
-    /too many requests/i,
-    /context.?length/i,
-    /token.?limit/i,
-    /parse.?error/i,
-    /syntax.?error/i,
-    /timeout/i,
-    /execution.?timed.?out/i,
-  ];
-
-  // Check first 2000 chars to avoid false positives in long output
-  const head = output.slice(0, 2000);
-  return errorPatterns.some((p) => p.test(head));
-}
-
-/**
- * Build a recovery instruction string from a RecoveryAction.
- */
-function buildRecoveryInstruction(
-  action: { type: string; delay?: number; maxAttempts?: number; reason: string; modifyPrompt?: string },
-): string {
-  const parts: string[] = [
-    `[HOOK: Error Recovery]`,
-    `Action: ${action.type}`,
-    `Reason: ${action.reason}`,
-  ];
-
-  if (action.delay) {
-    parts.push(`Delay: ${action.delay}ms before retry`);
-  }
-  if (action.maxAttempts) {
-    parts.push(`Max attempts: ${action.maxAttempts}`);
-  }
-  if (action.modifyPrompt) {
-    parts.push(`Modification: ${action.modifyPrompt}`);
-  }
-
-  return parts.join("\n");
-}