@tsconfigdotjson/vibe-os 0.2.0-rc.1 → 0.3.0

package/server/harnesses/hermes.ts

@@ -0,0 +1,259 @@
+// Hermes.
+//
+// It has no listing mode at all (`hermes model` is an interactive wizard), so
+// what is discoverable is its own configuration: which providers it has been
+// set up with and what it would use by default. The model and provider fields
+// stay free text with those as suggestions.
+//
+// No floor of well-known provider names. A Hermes provider id is account
+// configuration, so offering one that is not on this box would suggest a choice
+// that can only fail at launch.
+
+import { log } from "../log.ts";
+import { type HarnessAdapter, looksLikeLadder, run } from "./util.ts";
+
+export const HERMES_INSTALL =
+  "curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash";
+
+/**
+ * The reasoning ladder as of writing, used only when the help cannot be read.
+ * Not merged with what was discovered, because the list is the scale.
+ */
+const KNOWN_REASONING = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra",
+];
+
+/**
+ * One `hermes config get <key> --json`, parsed, or null.
+ *
+ * Null is "could not tell", never "not set": a key never written, a build that
+ * spells it differently and a Python traceback all arrive here the same way.
+ */
+async function hermesConfig(
+  binary: string,
+  key: string,
+): Promise<Record<string, unknown> | null> {
+  try {
+    const { stdout } = await run(binary, ["config", "get", key, "--json"], {
+      timeout: 20_000,
+      maxBuffer: 4 * 1024 * 1024,
+    });
+    const parsed: unknown = JSON.parse(stdout);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The levels `--reasoning` lists in its own help output.
+ *
+ * Hermes writes "Reasoning effort for this session: none, minimal, low, medium,
+ * high, xhigh, max, or ultra." across two wrapped lines, so the anchor is the
+ * first colon after the flag and the terminator is the full stop.
+ */
+export function reasoningLevels(help: string): string[] {
+  const section = /--reasoning[\s\S]{0,200}?:\s*([\s\S]{0,200}?)\./.exec(help);
+  if (!section) return [];
+  const levels = section[1]
+    .split(/,|\bor\b/)
+    .map((s) => s.trim())
+    .filter(Boolean);
+  return looksLikeLadder(levels) ? levels : [];
+}
+
+/** A field of a config block, when it is a non-empty string. */
+function str(
+  block: Record<string, unknown> | null,
+  key: string,
+): string | null {
+  const value = block?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+export const hermes: HarnessAdapter = {
+  spec: {
+    id: "hermes",
+    label: "Hermes",
+    command: "hermes",
+    // `/usr/local/bin` is its FHS default; `~/.local/bin` is what it uses when
+    // it cannot write there.
+    paths: ["~/.local/bin/hermes", "/usr/local/bin/hermes"],
+    // `--model` and `--provider` belong to the `chat` subcommand, so a profile
+    // that picks a model has to name it. Prepended rather than stored, because
+    // it is not a flag anyone should be able to delete in the editor.
+    leading: ["chat"],
+    resume: {
+      args: ["--continue"],
+      unless: ["--continue", "-c", "--resume", "-r"],
+    },
+    install: HERMES_INSTALL,
+    defaults: ["--yolo"],
+    fields: [
+      {
+        kind: "select",
+        key: "model",
+        label: "Model",
+        flag: "--model",
+        aliases: ["-m"],
+        free: true,
+        placeholder: "Default — whatever Hermes is set to",
+      },
+      {
+        kind: "select",
+        key: "provider",
+        label: "Provider",
+        flag: "--provider",
+        free: true,
+        placeholder: "Default — whatever Hermes is set to",
+        hint: "Providers this box is set up with. Add one with `hermes model` on the box and it appears here.",
+      },
+      {
+        kind: "select",
+        key: "reasoning",
+        label: "Thinking",
+        flag: "--reasoning",
+        options: KNOWN_REASONING.map((value) => ({ value })),
+        none: "Default — whatever Hermes picks",
+        hint: "Read off `hermes chat --help` on the box, so the ladder follows Hermes' releases.",
+      },
+      {
+        kind: "select",
+        key: "interface",
+        label: "Interface",
+        none: "Default — whatever Hermes picks",
+        specials: [
+          { value: "cli", label: "Classic — a plain REPL", flag: "--cli" },
+          {
+            value: "tui",
+            label: "Full screen — overlays and mouse selection",
+            flag: "--tui",
+          },
+        ],
+      },
+      {
+        kind: "toggle",
+        flag: "--yolo",
+        label: "Skip approvals",
+        hint: "Run dangerous commands without asking. Same trade as Claude's skip-every-check.",
+        warn: "This session will not ask before running anything. Reasonable on a box that is already a sandbox; think twice anywhere else.",
+      },
+      {
+        kind: "toggle",
+        flag: "--continue",
+        // `-c` is the short form and takes an optional session name. Only the
+        // bare form is this switch; `-c mine` is listed under `optional`.
+        aliases: ["-c"],
+        label: "Resume last conversation",
+        hint: "Pick up the most recent session rather than starting a new one.",
+      },
+      {
+        kind: "toggle",
+        flag: "--ignore-rules",
+        label: "Ignore rules and memory",
+        hint: "Skip AGENTS.md, SOUL.md and the memory directory for this session.",
+      },
+      {
+        kind: "toggle",
+        flag: "--ignore-user-config",
+        label: "Ignore user config",
+        hint: "Use defaults instead of ~/.hermes/config.yaml. Credentials still load.",
+      },
+      {
+        kind: "toggle",
+        flag: "--safe-mode",
+        label: "Safe mode",
+        hint: "Disable every customisation at once. The reproducible-run switch.",
+      },
+      {
+        kind: "toggle",
+        flag: "--checkpoints",
+        label: "Checkpoints",
+        hint: "Snapshot files before destructive edits, so /rollback can undo them.",
+      },
+      {
+        kind: "toggle",
+        flag: "--verbose",
+        label: "Verbose output",
+        hint: "Show full tool output rather than the collapsed form.",
+      },
+      {
+        kind: "toggle",
+        flag: "--pass-session-id",
+        label: "Pass session id",
+        hint: "Put the session id in the system prompt, so the agent can name its own session.",
+      },
+    ],
+    // From `hermes chat --help` on a real install rather than the docs, which
+    // list a `-p/--profile` the CLI does not accept.
+    valued: [
+      "--in",
+      "--resume",
+      "-r",
+      "--toolsets",
+      "-t",
+      "--skills",
+      "-s",
+      "--max-turns",
+      "--source",
+      "--image",
+      "--query",
+      "-q",
+    ],
+    optional: ["-c"],
+    extraPlaceholder: '--append-system-prompt "…"',
+  },
+
+  async discover(binary) {
+    // Concurrently: `hermes` is Python, so each invocation costs seconds of
+    // interpreter and import time before it does anything.
+    const [help, model, providers] = await Promise.all([
+      // `chat`, not the bare command: `--reasoning` is a flag of that
+      // subcommand, which is also the one a profile launches.
+      run(binary, ["chat", "--help"], {
+        timeout: 30_000,
+        maxBuffer: 4 * 1024 * 1024,
+      })
+        .then(({ stdout }) => stdout)
+        .catch(() => ""),
+      hermesConfig(binary, "model"),
+      hermesConfig(binary, "providers"),
+    ]);
+
+    const defaultProvider = str(model, "provider");
+    const defaultModel = str(model, "default");
+    const names = [
+      ...Object.keys(providers ?? {}).filter((n) => n.trim()),
+      ...(defaultProvider ? [defaultProvider] : []),
+    ];
+    const reasoning = reasoningLevels(help);
+
+    log.debug(
+      `hermes: ${names.length} providers, ` +
+        `${reasoning.length > 0 ? reasoning.join("/") : "no"} reasoning levels`,
+    );
+
+    return {
+      options: {
+        model: defaultModel ? [{ value: defaultModel }] : [],
+        provider: [...new Set(names)].sort().map((value) => ({ value })),
+        ...(reasoning.length > 0
+          ? { reasoning: reasoning.map((value) => ({ value })) }
+          : {}),
+      },
+      defaults: {
+        ...(defaultModel ? { model: defaultModel } : {}),
+        ...(defaultProvider ? { provider: defaultProvider } : {}),
+      },
+    };
+  },
+};

package/server/harnesses/util.ts

@@ -0,0 +1,181 @@
+// What every harness adapter needs to ask the box about a binary.
+//
+// Kept apart from the registry in `../harness.ts` so an adapter can import it
+// without importing the list of adapters it is itself a member of.
+
+import { execFile } from "node:child_process";
+import { stat } from "node:fs/promises";
+import { promisify } from "node:util";
+import type { HarnessReport, HarnessSpec } from "../../shared/harness.ts";
+
+export const home = process.env.HOME ?? "";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * The PATH a window's harness gets, so discovery sees what a window will.
+ *
+ * A window exports `$HOME/.local/bin` ahead of everything (see `launch` in
+ * `session.ts`). Without the same here, a CLI that is a Node script, like
+ * Codex, resolves but cannot start when `node` itself lives in
+ * `~/.local/bin`: `vibe-os doctor` over a plain `ssh host 'command'` called
+ * it installed with no version and could not read its login.
+ */
+const env = {
+  ...process.env,
+  PATH: `${home}/.local/bin:${process.env.PATH ?? ""}`,
+};
+
+export const run = (
+  file: string,
+  args: string[],
+  opts: { timeout?: number; maxBuffer?: number } = {},
+) => execFileAsync(file, args, { ...opts, env, encoding: "utf8" });
+
+/** `~/x` to `$HOME/x`, for the paths a spec lists. */
+export const expandHome = (p: string): string =>
+  p === "~" ? home : p.startsWith("~/") ? `${home}${p.slice(1)}` : p;
+
+/**
+ * Resolves a command through PATH, then the given locations, then symlinks.
+ *
+ * A login shell picks `~/.local/bin` up from `.profile`; a systemd service does
+ * not, and vibe-os is meant to run as one. Without the extra locations the
+ * server cannot find a binary the window will happily launch a moment later,
+ * because the window runs under a login-ish shell with that PATH restored and
+ * the server does not.
+ */
+export async function resolveBinary(
+  command: string,
+  extraPaths: string[],
+): Promise<string | null> {
+  const candidates: string[] = [];
+  try {
+    const { stdout } = await run(
+      "/bin/sh",
+      ["-c", 'command -v "$1"', "sh", command],
+      { timeout: 5_000 },
+    );
+    if (stdout.trim()) candidates.push(stdout.trim());
+  } catch {
+    // not on PATH; the explicit locations may still have it
+  }
+  candidates.push(...extraPaths.map(expandHome).filter(Boolean));
+
+  for (const candidate of candidates) {
+    try {
+      await stat(candidate);
+      const { stdout: real } = await run(
+        "/bin/sh",
+        ["-c", 'readlink -f "$1"', "sh", candidate],
+        { timeout: 5_000 },
+      );
+      return real.trim() || candidate;
+    } catch {
+      // next
+    }
+  }
+  return null;
+}
+
+/**
+ * Runs a command and returns everything it printed, whatever it exited with.
+ *
+ * For the questions whose answer is the text either way: `codex login status`
+ * prints "Not logged in" to stderr and exits 1, and that is an answer, not a
+ * failure. Null only when nothing ran at all.
+ */
+export async function output(
+  binary: string,
+  args: string[],
+  timeout = 30_000,
+): Promise<string | null> {
+  try {
+    const { stdout, stderr } = await run(binary, args, {
+      timeout,
+      maxBuffer: 4 * 1024 * 1024,
+    });
+    return `${stdout}\n${stderr}`;
+  } catch (err) {
+    const e = err as { stdout?: unknown; stderr?: unknown; killed?: boolean };
+    if (e.killed) return null;
+    const text = `${typeof e.stdout === "string" ? e.stdout : ""}\n${typeof e.stderr === "string" ? e.stderr : ""}`;
+    return text.trim() ? text : null;
+  }
+}
+
+/**
+ * The version-shaped token on the first line that has anything on it.
+ *
+ * Covers `2.1.3 (Claude Code)`, `codex-cli 0.160.1` and Cursor's date-shaped
+ * `2026.08.11-e8db854` alike. Only the first line is a claim about the binary
+ * itself; a wrapper or update notice printed after it must not become the
+ * answer.
+ */
+export function versionToken(stdout: string): string | null {
+  const first = stdout.split("\n").find((l) => l.trim()) ?? "";
+  const match = /\bv?(\d+(?:\.\d+)+[^\s()]*)/.exec(first);
+  return match ? match[1] : null;
+}
+
+/**
+ * What a status command says about being logged in, when it says anything.
+ *
+ * "Not logged in" contains "logged in", so the negative is checked first. Text
+ * this cannot read returns null rather than false: only a definite "no" should
+ * make the editor warn that a window will sit at a login prompt.
+ */
+export function loggedIn(text: string): boolean | null {
+  const lower = text.toLowerCase();
+  if (
+    /not\s+logged\s+in|logged\s+out|unauthenticated|no.*credentials/.test(lower)
+  )
+    return false;
+  if (/logged\s+in|signed\s+in|authenticated/.test(lower)) return true;
+  return null;
+}
+
+/**
+ * Checks that read a ladder have to keep its order.
+ *
+ * A thinking level is ordinal, so the list is the scale, and anything that does
+ * not look like a level means the parse caught a sentence. Half a list read out
+ * of a paragraph would be worse than none, so the caller falls back to its own.
+ */
+export const looksLikeLadder = (levels: string[]): boolean =>
+  levels.length >= 2 && levels.every((l) => /^[a-z][a-z0-9-]*$/.test(l));
+
+/** A check doctor prints, without importing doctor. */
+export interface HarnessCheck {
+  label: string;
+  ok: boolean;
+  detail: string;
+  fix?: string;
+}
+
+/** What an adapter's own discovery adds to the generic version and login. */
+export interface Discovery<D = unknown> {
+  /** Overrides the generic `--version` read, for a harness that prints oddly. */
+  version?: string | null;
+  options?: HarnessReport["options"];
+  defaults?: HarnessReport["defaults"];
+  notes?: HarnessReport["notes"];
+  /** Anything the adapter's own doctor checks need that the report does not carry. */
+  detail?: D;
+}
+
+/**
+ * A harness: a spec, plus whatever code it needs that data cannot say.
+ *
+ * Every hook is optional. A spec alone is a working harness, which is what a
+ * `~/.vibe-os/harnesses/*.json` file is.
+ */
+export interface HarnessAdapter<D = unknown> {
+  spec: HarnessSpec;
+  /** Reads models and options off the installed binary. */
+  discover?: (binary: string) => Promise<Discovery<D>>;
+  /** Shell run in the window before the harness starts. */
+  setup?: (where: { cwd: string; stateDir: string }) => string;
+  /** Doctor checks beyond installed and logged in. */
+  checks?: (report: HarnessReport, detail: D | undefined) => HarnessCheck[];
+}