openhermes 4.11.2 → 4.13.0

package/package.json

@@ -1,57 +1,58 @@
 {
-  "name": "openhermes",
-  "version": "4.11.2",
-  "description": "Autonomous agent orchestration for OpenCode.",
-  "type": "module",
-  "license": "MIT",
-  "engines": {
-    "bun": ">=1.0"
-  },
-  "main": "./index.ts",
-  "dependencies": {
-    "@opencode-ai/plugin": "1.15.0"
-  },
-  "exports": {
-    ".": "./index.ts",
-    "./bootstrap": "./bootstrap.ts"
-  },
-  "files": [
-    "index.ts",
-    "bootstrap.ts",
-    "tsconfig.json",
-    "ETHOS.md",
-    "CONTEXT.md",
-    "lib/",
-    "scripts/",
-    "harness/codex/",
-    "harness/instructions/",
-    "harness/skills/",
-    "harness/commands/",
-    "harness/agents/",
-    "harness/lib/"
-  ],
-  "scripts": {
-    "test": "bun test"
-  },
-  "keywords": [
-    "opencode",
-    "openhermes",
-    "orchestrator",
-    "skills",
-    "commands",
-    "agents",
-    "rules"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/nathwn12/openhermes.git"
-  },
-  "bugs": {
-    "url": "https://github.com/nathwn12/openhermes/issues"
-  },
-  "homepage": "https://github.com/nathwn12/openhermes#readme",
-  "author": "nathwn12",
-  "devDependencies": {
-    "@types/node": "^25.8.0"
-  }
+    "name": "openhermes",
+    "version": "4.13.0",
+    "description": "Autonomous agent orchestration for OpenCode.",
+    "type": "module",
+    "license": "MIT",
+    "engines": {
+        "bun": ">=1.0"
+    },
+    "main": "./index.ts",
+    "dependencies": {
+        "@opencode-ai/plugin": "1.15.0"
+    },
+    "exports": {
+        ".": "./index.ts",
+        "./bootstrap": "./bootstrap.ts"
+    },
+    "files": [
+        "index.ts",
+        "bootstrap.ts",
+        "tsconfig.json",
+        "ETHOS.md",
+        "CONTEXT.md",
+        "docs/",
+        "lib/",
+        "harness/codex/",
+        "harness/instructions/",
+        "harness/skills/",
+        "harness/agents/",
+        "harness/lib/"
+    ],
+    "scripts": {
+        "test": "bun test",
+        "typecheck": "bun tsc --noEmit"
+    },
+    "keywords": [
+        "opencode",
+        "openhermes",
+        "orchestrator",
+        "skills",
+        "commands",
+        "agents",
+        "rules"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/nathwn12/openhermes.git"
+    },
+    "bugs": {
+        "url": "https://github.com/nathwn12/openhermes/issues"
+    },
+    "homepage": "https://github.com/nathwn12/openhermes#readme",
+    "author": "nathwn12",
+    "devDependencies": {
+        "@types/node": "^25.8.0",
+        "typescript": "^6.0.3"
+    }
 }

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

@@ -1,197 +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);
-  });
-
-  // ---- 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;
-  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 as unknown as BackgroundManager;
-    }
-  }
-
-  // -----------------------------------------------------------------------
-  // 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"
-  );
-}