thoth-agents 0.1.6 → 0.1.8

package/README.md

@@ -43,11 +43,34 @@ provide the same hard runtime controls.
 
 | Harness | Status | Setup path | Notes |
 | --- | --- | --- | --- |
-| OpenCode | Stable default | `npx thoth-agents@latest install` or `install --agent=opencode` | Native plugin config, native `task` delegation, optional tmux panes, OpenCode provider auth. |
+| OpenCode | Stable default | `npx thoth-agents@latest install` or `npx thoth-agents@latest install --agent=opencode` | Native plugin config, native `task` delegation, optional tmux panes, OpenCode provider auth. |
 | Codex | Supported explicit path | `npx thoth-agents@latest install --agent=codex` | Installs ambient/root guidance, six role subagents, and a Personal plugin source. Requires `/plugins` and `/hooks` trust review. Some governance remains instruction-level. |
 
+OpenCode can load the plugin with:
+
+```jsonc
+{
+  "plugin": ["thoth-agents@latest"]
+}
+```
+
+That plugin entry is not a shell command. To run the installer or TUI, use the
+npm binary through a global install, `npx thoth-agents@latest`, or
+`pnpm dlx thoth-agents@latest`.
+
 ## Quick Start
 
+Run the binary with no arguments in an interactive terminal to open the
+multi-harness TUI:
+
+```bash
+npx thoth-agents@latest
+```
+
+The same no-argument binary invocation falls back to the OpenCode install path
+in CI, redirected, or `TERM=dumb` terminals. Use explicit commands when you
+need deterministic automation.
+
 ### OpenCode
 
 ```bash
@@ -69,6 +92,10 @@ For non-interactive setup:
 npx thoth-agents@latest install --no-tui --tmux=no --skills=yes
 ```
 
+Interactive status, list, update, sync, and model previews are available from
+the no-argument TUI. Command help also documents the explicit command names for
+terminal workflows.
+
 ### Codex
 
 Review the plan first, then install explicitly:

package/dist/chunk-DYGVRAMS.js

@@ -0,0 +1,182 @@
+// src/utils/subprocess.ts
+import {
+  spawn as nodeSpawn,
+  spawnSync as nodeSpawnSync
+} from "child_process";
+import { Readable } from "stream";
+function emptyReadableStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function toWebReadable(stream) {
+  if (!stream) {
+    return emptyReadableStream();
+  }
+  return Readable.toWeb(
+    stream
+  );
+}
+function fallbackStdin() {
+  return {
+    write: () => void 0,
+    end: () => void 0
+  };
+}
+function spawn(command, options = {}) {
+  const child = nodeSpawn(command[0], command.slice(1), {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: [
+      options.stdin ?? "pipe",
+      options.stdout ?? "pipe",
+      options.stderr ?? "pipe"
+    ]
+  });
+  const managed = {
+    stdin: child.stdin ?? fallbackStdin(),
+    stdout: toWebReadable(child.stdout),
+    stderr: toWebReadable(child.stderr),
+    exited: new Promise((resolve) => {
+      child.on("exit", (code) => {
+        managed.exitCode = code;
+        resolve(code ?? 1);
+      });
+      child.on("error", () => {
+        managed.exitCode = 1;
+        resolve(1);
+      });
+    }),
+    exitCode: child.exitCode,
+    kill: () => {
+      child.kill();
+    }
+  };
+  return managed;
+}
+function spawnSync(command, options = {}) {
+  const result = nodeSpawnSync(command[0], command.slice(1), {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: [
+      options.stdin ?? "ignore",
+      options.stdout ?? "pipe",
+      options.stderr ?? "pipe"
+    ]
+  });
+  return { exitCode: result.status };
+}
+
+// src/cli/system.ts
+import { statSync } from "fs";
+var cachedOpenCodePath = null;
+function getOpenCodePaths() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return [
+    // PATH (try this first)
+    "opencode",
+    // User local installations (Linux & macOS)
+    `${home}/.local/bin/opencode`,
+    `${home}/.opencode/bin/opencode`,
+    `${home}/bin/opencode`,
+    // System-wide installations
+    "/usr/local/bin/opencode",
+    "/opt/opencode/bin/opencode",
+    "/usr/bin/opencode",
+    "/bin/opencode",
+    // macOS specific
+    "/Applications/OpenCode.app/Contents/MacOS/opencode",
+    `${home}/Applications/OpenCode.app/Contents/MacOS/opencode`,
+    // Homebrew (macOS & Linux)
+    "/opt/homebrew/bin/opencode",
+    "/home/linuxbrew/.linuxbrew/bin/opencode",
+    `${home}/homebrew/bin/opencode`,
+    // macOS user Library
+    `${home}/Library/Application Support/opencode/bin/opencode`,
+    // Snap (Linux)
+    "/snap/bin/opencode",
+    "/var/snap/opencode/current/bin/opencode",
+    // Flatpak (Linux)
+    "/var/lib/flatpak/exports/bin/ai.opencode.OpenCode",
+    `${home}/.local/share/flatpak/exports/bin/ai.opencode.OpenCode`,
+    // Nix (Linux/macOS)
+    "/nix/store/opencode/bin/opencode",
+    `${home}/.nix-profile/bin/opencode`,
+    "/run/current-system/sw/bin/opencode",
+    // Cargo (Rust toolchain)
+    `${home}/.cargo/bin/opencode`,
+    // npm/npx global
+    `${home}/.npm-global/bin/opencode`,
+    "/usr/local/lib/node_modules/opencode/bin/opencode",
+    // Yarn global
+    `${home}/.yarn/bin/opencode`,
+    // PNPM
+    `${home}/.pnpm-global/bin/opencode`
+  ];
+}
+function resolveOpenCodePath() {
+  if (cachedOpenCodePath) {
+    return cachedOpenCodePath;
+  }
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    if (opencodePath === "opencode") continue;
+    try {
+      const stat = statSync(opencodePath);
+      if (stat.isFile()) {
+        cachedOpenCodePath = opencodePath;
+        return opencodePath;
+      }
+    } catch {
+    }
+  }
+  return "opencode";
+}
+async function isOpenCodeInstalled() {
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    try {
+      const proc = spawn([opencodePath, "--version"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      await proc.exited;
+      if (proc.exitCode === 0) {
+        cachedOpenCodePath = opencodePath;
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+async function getOpenCodeVersion() {
+  const opencodePath = resolveOpenCodePath();
+  try {
+    const proc = spawn([opencodePath, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const output = await new Response(proc.stdout).text();
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return output.trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function getOpenCodePath() {
+  const path = resolveOpenCodePath();
+  return path === "opencode" ? null : path;
+}
+
+export {
+  spawn,
+  spawnSync,
+  isOpenCodeInstalled,
+  getOpenCodeVersion,
+  getOpenCodePath
+};