aiur-cli 0.0.1 → 0.0.2

package/README.md

@@ -4,6 +4,14 @@
 
 Oversee a fleet of coding agents that **coordinate via events**.
 
+> [!WARNING]
+> **Use at your own risk.** Aiur is an unstable, vibecoded engineering preview for trusted
+> environments only. It **bypasses all agent permission prompts** and has very few efficiency
+> optimizations. Suggested for simple tasks under supervision.
+>
+> Provided "as is", without warranty of any kind. You assume all risk for any cost, token
+> spend, data loss, or damage from running it.
+
 ## Install
 
 ```bash

package/bin/aiur.js

@@ -5,6 +5,17 @@ const { spawnSync } = require("node:child_process");
 const path = require("node:path");
 const fs = require("node:fs");
 
+// Node's spawnSync reports a missing executable via `result.error`; some
+// runtimes (e.g. Bun) throw instead. Normalize to the error-return shape so a
+// missing tmux/opencode/brew degrades gracefully rather than crashing.
+function safeSpawn(command, args, options) {
+  try {
+    return spawnSync(command, args, options);
+  } catch (error) {
+    return { error, status: null, stdout: "" };
+  }
+}
+
 // Map this host to the platform package that carries its OTP release.
 const PLATFORMS = {
   "darwin arm64": "darwin-arm64",
@@ -61,51 +72,138 @@ function resolveReleaseDir() {
   return path.join(path.dirname(pkgJson), "release");
 }
 
+// Pinned opencode version — single source of truth is this package's
+// package.json `opencodeVersion` (kept in sync with scripts/postinstall.mjs
+// and mise.toml).
+function opencodeVersion() {
+  const pkg = JSON.parse(
+    fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf8"),
+  );
+  return pkg.opencodeVersion;
+}
+
+// ---------------------------------------------------------------------------
+// Lazy first-run provisioning
+//
+// The npm postinstall (scripts/postinstall.mjs) provisions tmux + opencode, but
+// bun/pnpm/yarn block postinstall scripts by default — a package cannot force a
+// consumer to run them. So the launcher guarantees the peer tools here, on the
+// first real (TUI) launch, regardless of which package manager installed
+// aiur-cli. Both steps are idempotent (skip when already satisfied); tmux is a
+// hard requirement, opencode is best-effort. Honors the same AIUR_SKIP_* env
+// vars as the postinstall. This logic mirrors postinstall.mjs intentionally —
+// the launcher stays dependency-free and cannot import the .mjs counterpart.
+// ---------------------------------------------------------------------------
+
 function tmuxVersion() {
-  const result = spawnSync("tmux", ["-V"], { encoding: "utf8" });
+  const result = safeSpawn("tmux", ["-V"], { encoding: "utf8" });
   if (result.error || result.status !== 0) return null;
   const match = /tmux\s+(\d+)\.(\d+)/.exec(result.stdout || "");
   if (!match) return null;
   return [Number(match[1]), Number(match[2])];
 }
 
+function tmuxSatisfiesMin() {
+  const version = tmuxVersion();
+  if (!version) return false;
+  const [major, minor] = version;
+  const [needMajor, needMinor] = MIN_TMUX;
+  return major > needMajor || (major === needMajor && minor >= needMinor);
+}
+
 function tmuxHint() {
   return process.platform === "darwin"
     ? "install it with: brew install tmux"
     : "install it with: apt install tmux (or your distro's package manager)";
 }
 
-function preflightTmux() {
-  const version = tmuxVersion();
-  if (!version) {
-    fail(`tmux is required but was not found on PATH. ${tmuxHint()}`);
+// Best-effort system install of tmux. macOS uses Homebrew; Linux uses the first
+// package manager present. Never invokes sudo (a hidden password prompt mid-
+// launch would hang). Returns false so the caller can fail with a clear hint.
+function installTmux(platform) {
+  const has = (bin) => !safeSpawn(bin, ["--version"], { stdio: "ignore" }).error;
+  if (platform === "darwin") {
+    if (!has("brew")) return false;
+    return safeSpawn("brew", ["install", "tmux"], { stdio: "inherit" }).status === 0;
   }
-  const [major, minor] = version;
-  const [needMajor, needMinor] = MIN_TMUX;
-  const tooOld =
-    major < needMajor || (major === needMajor && minor < needMinor);
-  if (tooOld) {
+  if (platform === "linux") {
+    const managers = [
+      ["apt-get", ["install", "-y", "tmux"]],
+      ["dnf", ["install", "-y", "tmux"]],
+      ["apk", ["add", "tmux"]],
+      ["pacman", ["-S", "--noconfirm", "tmux"]],
+    ];
+    for (const [bin, argv] of managers) {
+      if (!has(bin)) continue;
+      return safeSpawn(bin, argv, { stdio: "inherit" }).status === 0;
+    }
+  }
+  return false;
+}
+
+// tmux is required — the TUI runs inside it — so this provisions if missing and
+// fails hard only when tmux still can't be made available.
+function ensureTmux() {
+  if (tmuxSatisfiesMin()) return;
+  if (process.env.AIUR_SKIP_TMUX_INSTALL !== "1") {
+    process.stderr.write(
+      `aiur: tmux (>= ${MIN_TMUX.join(".")}) runs the interactive TUI; installing it…\n`,
+    );
+    installTmux(process.platform);
+  }
+  if (!tmuxSatisfiesMin()) {
+    const v = tmuxVersion();
     fail(
-      `tmux ${major}.${minor} is too old; aiur needs ` +
-        `>= ${needMajor}.${needMinor}. ${tmuxHint()}`,
+      v
+        ? `tmux ${v[0]}.${v[1]} is too old; aiur needs >= ${MIN_TMUX.join(".")}. ${tmuxHint()}`
+        : `tmux is required but was not found on PATH. ${tmuxHint()}`,
     );
   }
 }
 
-function preflightOpencode() {
-  const result = spawnSync("opencode", ["--version"], { stdio: "ignore" });
-  if (result.error || result.status !== 0) {
+// True only when the pinned opencode is on PATH; a wrong version (e.g. 1.17.x,
+// which broke the panes) must be replaced, so presence alone isn't enough.
+function opencodeMatchesPin() {
+  const result = safeSpawn("opencode", ["--version"], { encoding: "utf8" });
+  return !result.error && result.status === 0 && (result.stdout || "").trim() === opencodeVersion();
+}
+
+// Install the pinned opencode globally. Forces online so it never inherits an
+// --offline / prefer-offline context (CI, mirrors, air-gapped) that would fail
+// on a cold cache — mirrors scripts/postinstall.mjs:installOpencode.
+function installOpencode() {
+  const env = { ...process.env };
+  delete env.npm_config_offline;
+  delete env.npm_config_prefer_offline;
+  const result = safeSpawn(
+    "npm",
+    ["install", "-g", `opencode-ai@${opencodeVersion()}`, "--no-offline", "--no-prefer-offline"],
+    { stdio: "inherit", env },
+  );
+  return !result.error && result.status === 0;
+}
+
+// opencode powers the interactive "take the wheel" panes. Non-fatal: everything
+// else works without it.
+function ensureOpencode() {
+  if (opencodeMatchesPin()) return;
+  if (process.env.AIUR_SKIP_OPENCODE_INSTALL !== "1") {
     process.stderr.write(
-      "aiur: opencode was not found on PATH. The interactive 'take the wheel' " +
-        "feature needs it; everything else works without it. " +
-        "Install from https://opencode.ai\n",
+      `aiur: provisioning opencode@${opencodeVersion()} (one-time, for the interactive 'take the wheel' panes)…\n`,
     );
+    installOpencode();
+    if (opencodeMatchesPin()) return;
   }
+  process.stderr.write(
+    "aiur: opencode was not found on PATH. The interactive 'take the wheel' " +
+      "feature needs it; everything else works without it. " +
+      "Install from https://opencode.ai\n",
+  );
 }
 
 // `init` and `--version` run as foreground one-shots that never start the
-// tmux-backed UI, so their tmux/opencode preflight is irrelevant — and tmux may
-// legitimately be absent on a machine that only ever runs `aiur init`.
+// tmux-backed UI, so their tmux/opencode provisioning is irrelevant — and tmux
+// may legitimately be absent on a machine that only ever runs `aiur init`.
 function isForegroundOneShot(argv) {
   for (const arg of argv) {
     if (arg === "--version") return true;
@@ -119,8 +217,8 @@ function main() {
   const releaseDir = resolveReleaseDir();
 
   if (!isForegroundOneShot(process.argv.slice(2))) {
-    preflightTmux();
-    preflightOpencode();
+    ensureTmux();
+    ensureOpencode();
   }
 
   const pkgRoot = path.resolve(__dirname, "..");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aiur-cli",
-  "version": "0.0.1",
-  "description": "AI Unit Runtime for Executors — placeholder, full release coming soon.",
+  "version": "0.0.2",
+  "description": "AI Unit Runtime for Executors.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/its-everdred/aiur",
   "repository": {
@@ -12,20 +12,23 @@
     "aiur": "bin/aiur.js"
   },
   "scripts": {
+    "postinstall": "node scripts/postinstall.mjs",
     "test": "bun test"
   },
   "files": [
     "bin/aiur.js",
     "libexec/aiur-engine.sh",
+    "scripts/postinstall.mjs",
     "share/aiur.tmux.conf"
   ],
   "engines": {
     "node": ">=18"
   },
+  "opencodeVersion": "1.15.6",
   "optionalDependencies": {
-    "aiur-cli-linux-x64": "0.0.1",
-    "aiur-cli-linux-arm64": "0.0.1",
-    "aiur-cli-darwin-x64": "0.0.1",
-    "aiur-cli-darwin-arm64": "0.0.1"
+    "aiur-cli-linux-x64": "0.0.2",
+    "aiur-cli-linux-arm64": "0.0.2",
+    "aiur-cli-darwin-x64": "0.0.2",
+    "aiur-cli-darwin-arm64": "0.0.2"
   }
 }

package/scripts/postinstall.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+// Provisions the peer tools every aiur user needs at runtime, so that a single
+// global `npm install -g aiur-cli` yields a working install with nothing left
+// to install by hand:
+//
+//   - tmux      the multiplexer the interactive TUI runs inside. aiur refuses
+//               to launch without tmux >= MIN_TMUX, so it is a hard runtime
+//               requirement (not merely nice-to-have).
+//   - opencode  the peer CLI behind the interactive "take the wheel" panes.
+//
+// A global aiur-cli install does not link a dependency's bin onto PATH, and
+// tmux is a system package rather than an npm one, so we provision both here.
+// Every step is idempotent (skips when already satisfied) and non-fatal (a
+// failure prints a hint but never breaks the aiur install).
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+// ---------------------------------------------------------------------------
+// opencode
+// ---------------------------------------------------------------------------
+
+// Pinned opencode version, read from package.json `opencodeVersion` (single
+// source of truth — keep in sync with mise.toml). aiur's opencode pane
+// integration is validated against this version; 1.17.x broke custom-provider
+// model resolution (ProviderModelNotFoundError), blanking the chat panes.
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+export const OPENCODE_PACKAGE = `opencode-ai@${pkg.opencodeVersion}`;
+
+// True only when the *pinned* opencode version is on PATH. A wrong (e.g.
+// newer) version must be reinstalled — leaving 1.17.x in place keeps the
+// panes broken — so a mere presence check isn't enough.
+export function opencodeMatchesPin() {
+  const result = spawnSync("opencode", ["--version"], { encoding: "utf8" });
+  return !result.error && result.status === 0 && result.stdout.trim() === pkg.opencodeVersion;
+}
+
+// Build the nested-install command. Provisioning fetches opencode from the
+// registry, so it must NOT inherit an offline context from the outer
+// `npm install` that triggered this postinstall — CI's `npm install -g
+// --offline`, a `prefer-offline` config, or an air-gapped box. npm hands those
+// to lifecycle scripts as npm_config_* env vars; a naive nested install
+// inherits them and dies with ENOTCACHED on a cold cache, silently leaving
+// opencode unprovisioned. We force online two ways (CLI flags outrank env, and
+// stripping the env vars is belt-and-suspenders) so a plain `npm install -g
+// aiur-cli` provisions opencode regardless of how the parent was invoked.
+export function opencodeInstallSpec(env = process.env) {
+  const childEnv = { ...env };
+  delete childEnv.npm_config_offline;
+  delete childEnv.npm_config_prefer_offline;
+  return {
+    command: "npm",
+    args: ["install", "-g", OPENCODE_PACKAGE, "--no-offline", "--no-prefer-offline"],
+    env: childEnv,
+  };
+}
+
+export function installOpencode() {
+  const spec = opencodeInstallSpec();
+  const result = spawnSync(spec.command, spec.args, { stdio: "inherit", env: spec.env });
+  return !result.error && result.status === 0;
+}
+
+export function provisionOpencode({
+  env = process.env,
+  isPresent = opencodeMatchesPin,
+  install = installOpencode,
+  log = (message) => process.stderr.write(message + "\n"),
+} = {}) {
+  if (env.AIUR_SKIP_OPENCODE_INSTALL === "1") return "skipped:disabled";
+  if (isPresent()) return "skipped:present";
+
+  log(`aiur: installing pinned opencode (${OPENCODE_PACKAGE}) for the interactive 'take the wheel' feature…`);
+
+  if (install()) return "installed";
+
+  log(
+    "aiur: couldn't install opencode automatically. Install it manually: " +
+      "npm install -g opencode-ai (see https://opencode.ai)",
+  );
+  return "failed";
+}
+
+// ---------------------------------------------------------------------------
+// tmux
+// ---------------------------------------------------------------------------
+
+// Minimum tmux the TUI needs. Keep in sync with the runtime preflight in
+// bin/aiur.js — that preflight stays as a safety net, this just front-loads
+// the install so the first `aiur` run isn't a dead end.
+export const MIN_TMUX = [3, 3];
+
+function tmuxHint(platform = process.platform) {
+  return platform === "darwin"
+    ? "install it with: brew install tmux"
+    : "install it with: apt install tmux (or your distro's package manager)";
+}
+
+// True only when a new-enough tmux is on PATH. The TUI won't launch with an
+// older tmux, so — as with opencode's pin — presence alone isn't enough.
+export function tmuxSatisfiesMin(run = (cmd, argv) => spawnSync(cmd, argv, { encoding: "utf8" })) {
+  const result = run("tmux", ["-V"]);
+  if (result.error || result.status !== 0) return false;
+  const match = /tmux\s+(\d+)\.(\d+)/.exec(result.stdout || "");
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const [needMajor, needMinor] = MIN_TMUX;
+  return major > needMajor || (major === needMajor && minor >= needMinor);
+}
+
+// Best-effort system install of tmux. macOS uses Homebrew; Linux uses the
+// first package manager that is present. Returns false (so the caller can
+// print a manual hint) when no usable installer exists or the install fails —
+// including the common non-root case where a Linux package manager can't
+// proceed. We never invoke sudo: a hidden password prompt during `npm install`
+// would hang the install.
+export function installTmux(platform = process.platform) {
+  const has = (bin) => !spawnSync(bin, ["--version"], { stdio: "ignore" }).error;
+
+  if (platform === "darwin") {
+    if (!has("brew")) return false;
+    return spawnSync("brew", ["install", "tmux"], { stdio: "inherit" }).status === 0;
+  }
+
+  if (platform === "linux") {
+    const managers = [
+      ["apt-get", ["install", "-y", "tmux"]],
+      ["dnf", ["install", "-y", "tmux"]],
+      ["apk", ["add", "tmux"]],
+      ["pacman", ["-S", "--noconfirm", "tmux"]],
+    ];
+    for (const [bin, argv] of managers) {
+      if (!has(bin)) continue;
+      return spawnSync(bin, argv, { stdio: "inherit" }).status === 0;
+    }
+  }
+
+  return false;
+}
+
+export function provisionTmux({
+  env = process.env,
+  isPresent = tmuxSatisfiesMin,
+  install = installTmux,
+  platform = process.platform,
+  log = (message) => process.stderr.write(message + "\n"),
+} = {}) {
+  if (env.AIUR_SKIP_TMUX_INSTALL === "1") return "skipped:disabled";
+  if (isPresent()) return "skipped:present";
+
+  log(
+    `aiur: tmux (>= ${MIN_TMUX.join(".")}) not found; aiur's interactive TUI runs inside tmux. Installing…`,
+  );
+
+  if (install(platform)) return "installed";
+
+  log(`aiur: couldn't install tmux automatically. ${tmuxHint(platform)}`);
+  return "failed";
+}
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+// Run only when invoked directly as the postinstall step, not when a test
+// imports the helpers above. tmux is provisioned first — it is the hard
+// requirement — then opencode for the optional panes.
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  provisionTmux();
+  provisionOpencode();
+}