@rebon/cli-win32-x64 0.1.3

package/README.md

@@ -0,0 +1,133 @@
+# rebon
+
+An agent CLI for coding and more — a terminal harness that drives an LLM through
+a real agent loop with tools, sessions, permissions, and a full TUI.
+
+## Install
+
+```bash
+npm install -g @rebon/cli
+```
+
+Upgrade later:
+
+```bash
+npm install -g @rebon/cli@latest
+```
+
+`@rebon/cli` is a thin launcher that pulls the matching native binary as
+an optional dependency. Supported platforms: `win32-x64`, `darwin-x64`,
+`darwin-arm64`, `linux-x64`, `linux-arm64`.
+
+> If install fails with "missing optional platform package", you likely passed
+> `--omit=optional` or `--no-optional`. Reinstall without that flag.
+
+## Quick start
+
+```bash
+# Local TUI in the current directory
+rebon
+
+# Resume a previous session
+rebon --resume sess-0-1712937600000
+
+# Override the active provider / model
+rebon --provider openrouter --model gpt-5.5
+
+# Run as an ACP JSON-RPC server on stdio (for editor / IDE integrations)
+rebon --acp
+```
+
+The first run drops you into onboarding: pick a provider, sign in (OAuth +
+PKCE for Claude / OpenAI, or paste an API key), and you're in.
+
+## CLI flags
+
+| Flag                | Purpose                                                      |
+| ------------------- | ------------------------------------------------------------ |
+| `--acp`             | Run as an ACP JSON-RPC server on stdio.                      |
+| `--provider <name>` | Override `activeCustomProvider` from `~/.rebon/config.json`. |
+| `--model <id>`      | Override the resolved provider's default model.              |
+| `--resume <id>`     | Load an on-disk transcript and replay it into the TUI.       |
+
+## Config & data
+
+- `~/.rebon/config.json` — providers, models, credentials, defaults.
+- `~/.rebon/sessions/` — saved transcripts.
+- `~/.rebon/skills/`, `~/.rebon/agents/`, `~/.rebon/memory/` — user assets.
+- `$REBON_LOG_DIR/rebon.log` — TUI log file (defaults to
+  `%TEMP%/rebon/logs/rebon.log` on Windows, `$TMPDIR/rebon/logs/rebon.log`
+  elsewhere). `--acp` mode logs to stderr instead.
+
+Project-level overrides live under `.rebon/` and `.claude/` in your working
+directory.
+
+## What you get
+
+- **Local TUI** — prompt input with history, paste, image paste, `@`-mention
+  and slash-command pickers, queued submissions, mode cycling; streaming
+  transcript with markdown, tool grouping, thinking blocks, plan approval,
+  permission modal; full dialog stack for onboarding, settings, resume,
+  rewind, quick-open, history search, global search, tasks, background
+  tasks, teams, agents.
+- **Agentic tool loop** — Bash / PowerShell, Read / Write / Edit, Glob /
+  Grep, Sleep, TaskCreate / TaskUpdate / TaskList / TaskGet / TaskStop,
+  Agent, SkillTool, AskUserQuestion, SendMessage, EnterPlanMode /
+  ExitPlanMode, ToolSearch, Team{Create,Delete,Files,Mailbox,Manager},
+  Worktree, plus MCP tools (stdio, Streamable HTTP, legacy SSE).
+- **Providers** — Anthropic, OpenAI, and OpenAI-Responses, with streaming,
+  compact / context-prune passes, and automatic session titles.
+- **Permissions, hooks, sandbox** — fine-grained allow / deny for shell,
+  filesystem, web-fetch, and skill invocations; user-defined hooks; sandbox
+  config with violation reporting.
+- **Skills, agents, memory** — bundled and user skills; spawnable
+  worker agents and a coordinator for background tasks; a persistent memory
+  layer with recall and surfacing.
+- **ACP server** — drive Rebon from an editor over stdio JSON-RPC:
+  `initialize`, `session/new`, `session/load`, `session/list`,
+  `session/prompt`, `session/cancel`, reverse-RPC permission prompts,
+  streamed tool output.
+
+## Common tasks
+
+```bash
+# Start a fresh session in the current repo
+rebon
+
+# Resume the last session you worked on (use Tab in the TUI to browse)
+rebon --resume <session-id>
+
+# Plug Rebon into an editor over ACP (the editor manages stdio for you)
+rebon --acp
+
+# Override provider/model without editing config
+rebon --provider anthropic --model claude-opus-4-7
+```
+
+Inside the TUI:
+
+- `?` — keyboard help
+- `/` — slash-command picker
+- `@` — file / symbol mention
+- `Tab` — switch panel / list
+- `Esc` — cancel current step or dismiss a dialog
+
+## Updating
+
+`rebon` ships with a built-in updater that checks for new releases on launch.
+You can also just rerun:
+
+```bash
+npm install -g @rebon/cli@latest
+```
+
+## Troubleshooting
+
+- **"missing optional platform package"** — reinstall without
+  `--omit=optional` / `--no-optional` / `--ignore-optional`.
+- **"unsupported platform"** — your `process.platform`/`process.arch` is not
+  one of the five supported targets.
+- **TUI looks scrambled** — make sure your terminal supports truecolor and
+  Unicode width tables (modern Windows Terminal, iTerm2, Alacritty, WezTerm,
+  Kitty all work). The legacy `cmd.exe` and `conhost` are not supported.
+- **Logs** — check `$REBON_LOG_DIR/rebon.log` (TUI) or stderr (`--acp`).

package/bin/rebon.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+"use strict";
+
+const {
+  readPackageInfo,
+  resolveExecutable,
+  spawnResolvedExecutable,
+} = require("../lib/windows-managed");
+
+const resolved = resolveExecutable(readPackageInfo());
+if (!resolved.exe) {
+  const detail = resolved.installError ? ` (${resolved.installError.message})` : "";
+  console.error(`rebon: could not find installed rebon.exe${detail}. Try reinstalling the npm package without disabling scripts.`);
+  process.exit(1);
+}
+
+if (resolved.usedFallback) {
+  const detail = resolved.installError ? `: ${resolved.installError.message}` : "";
+  console.error(`rebon: using package payload fallback${detail}. Future npm upgrades may require closing this rebon process.`);
+}
+
+spawnResolvedExecutable(resolved, process.argv.slice(2), require("child_process").spawn);

package/lib/windows-managed.js

@@ -0,0 +1,389 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const CURRENT_MANIFEST = "current.json";
+const EXECUTABLE_NAME = "rebon.exe";
+const PAYLOAD_DIR = "payload";
+const VERSIONS_DIR = "versions";
+const STAGING_DIR = "staging";
+
+function defaultPackageRoot() {
+  return path.resolve(__dirname, "..");
+}
+
+function managedBinDir() {
+  const base = process.env.LOCALAPPDATA || (process.env.USERPROFILE && path.join(process.env.USERPROFILE, ".rebon"));
+  if (!base) {
+    return null;
+  }
+  return path.join(base, "rebon", "bin");
+}
+
+function requireManagedBinDir() {
+  const binDir = managedBinDir();
+  if (!binDir) {
+    throw new Error("LOCALAPPDATA and USERPROFILE are both unset; cannot choose a per-user install directory");
+  }
+  return binDir;
+}
+
+function sanitizeVersionPart(value) {
+  return String(value || "unknown").replace(/[^0-9A-Za-z._-]/g, "_");
+}
+
+function firstString(candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.length > 0) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+function packageBuildId(packageJson) {
+  const rebon = packageJson && packageJson.rebon;
+  return firstString([
+    rebon && rebon.build,
+    rebon && rebon.buildId,
+    rebon && rebon.commit,
+    rebon && rebon.hash,
+    packageJson && packageJson.rebonBuild,
+    packageJson && packageJson.rebonBuildId,
+  ]);
+}
+
+function versionKeyFromPackageJson(packageJson) {
+  const version = sanitizeVersionPart(packageJson && packageJson.version);
+  const buildId = packageBuildId(packageJson);
+  return buildId ? `${version}-${sanitizeVersionPart(buildId)}` : version;
+}
+
+function payloadSignature(payloadPath) {
+  const stat = fs.statSync(payloadPath);
+  return { size: stat.size, mtimeMs: Math.trunc(stat.mtimeMs) };
+}
+
+function readPackageInfo(packageRoot) {
+  const root = path.resolve(packageRoot || defaultPackageRoot());
+  const packageJson = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+  const payloadDir = path.join(root, PAYLOAD_DIR);
+  const payloadPath = path.join(payloadDir, EXECUTABLE_NAME);
+  return {
+    packageRoot: root,
+    name: String(packageJson.name || "rebon"),
+    version: String(packageJson.version || "unknown"),
+    versionKey: versionKeyFromPackageJson(packageJson),
+    payloadDir,
+    payloadPath,
+    payload: fs.existsSync(payloadPath) ? payloadSignature(payloadPath) : null,
+  };
+}
+
+function managedRelativeExecutable(versionKey) {
+  return `${VERSIONS_DIR}/${versionKey}/${EXECUTABLE_NAME}`;
+}
+
+function payloadSpecificVersionKey(packageInfo) {
+  if (!packageInfo.payload) {
+    return packageInfo.versionKey;
+  }
+  return `${packageInfo.versionKey}-${packageInfo.payload.size}-${packageInfo.payload.mtimeMs}`;
+}
+
+function acceptedVersionKeys(packageInfo) {
+  const keys = [packageInfo.versionKey];
+  const payloadKey = payloadSpecificVersionKey(packageInfo);
+  if (payloadKey !== packageInfo.versionKey) {
+    keys.push(payloadKey);
+  }
+  return keys;
+}
+
+function layoutForVersion(binDir, versionKey) {
+  const versionDir = path.join(binDir, VERSIONS_DIR, versionKey);
+  const stagingDir = path.join(binDir, STAGING_DIR, versionKey);
+  return {
+    versionDir,
+    stagingDir,
+    exePath: path.join(versionDir, EXECUTABLE_NAME),
+    manifestPath: path.join(binDir, CURRENT_MANIFEST),
+    manifestRelativePath: managedRelativeExecutable(versionKey),
+  };
+}
+
+function normalizeManifestPath(value) {
+  return String(value || "").replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+
+function resolveManifestPath(binDir, manifestPath) {
+  if (typeof manifestPath !== "string" || path.isAbsolute(manifestPath)) {
+    return null;
+  }
+
+  const resolved = path.resolve(binDir, manifestPath.replace(/[\\/]+/g, path.sep));
+  const relative = path.relative(path.resolve(binDir), resolved);
+  if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    return null;
+  }
+  return resolved;
+}
+
+function readCurrentManifest(binDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(binDir, CURRENT_MANIFEST), "utf8"));
+  } catch (_) {
+    return null;
+  }
+}
+
+function payloadMatchesManifest(manifest, packageInfo) {
+  if (!packageInfo.payload) {
+    return true;
+  }
+  if (!manifest.payload) {
+    return false;
+  }
+  return (
+    Number(manifest.payload.size) === packageInfo.payload.size &&
+    Math.trunc(Number(manifest.payload.mtimeMs)) === packageInfo.payload.mtimeMs
+  );
+}
+
+function manifestMatchesPackage(manifest, binDir, packageInfo) {
+  if (!manifest) {
+    return false;
+  }
+  if (manifest.package !== packageInfo.name || manifest.version !== packageInfo.version) {
+    return false;
+  }
+  if (!acceptedVersionKeys(packageInfo).includes(manifest.versionKey)) {
+    return false;
+  }
+  if (normalizeManifestPath(manifest.path) !== managedRelativeExecutable(manifest.versionKey)) {
+    return false;
+  }
+
+  const resolved = resolveManifestPath(binDir, manifest.path);
+  return Boolean(resolved && fs.existsSync(resolved) && payloadMatchesManifest(manifest, packageInfo));
+}
+
+function readInstalledManifest(packageInfo) {
+  const binDir = managedBinDir();
+  if (!binDir) {
+    return null;
+  }
+
+  const manifest = readCurrentManifest(binDir);
+  if (!manifestMatchesPackage(manifest, binDir, packageInfo)) {
+    return null;
+  }
+  return manifest;
+}
+
+function readInstalledExecutable(packageInfo) {
+  const binDir = managedBinDir();
+  const manifest = readInstalledManifest(packageInfo);
+  if (!binDir || !manifest) {
+    return null;
+  }
+  return resolveManifestPath(binDir, manifest.path);
+}
+
+function writeManifest(manifestPath, manifest) {
+  const nonce = Math.random().toString(36).slice(2, 10);
+  const tmpPath = `${manifestPath}.${process.pid}.${nonce}.tmp`;
+  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+  fs.writeFileSync(tmpPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+  fs.renameSync(tmpPath, manifestPath);
+}
+
+function copyPayloadDirectory(srcDir, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const src = path.join(srcDir, entry.name);
+    const dest = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyPayloadDirectory(src, dest);
+    } else if (entry.isFile()) {
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(src, dest);
+    }
+  }
+}
+
+function resetDirectory(dir) {
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch (_) {
+  }
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function removeDirectoryIfExists(dir) {
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch (_) {
+  }
+}
+
+function cleanupDirectoryEntries(rootDir, keepName) {
+  let entries;
+  try {
+    entries = fs.readdirSync(rootDir, { withFileTypes: true });
+  } catch (_) {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === keepName) {
+      continue;
+    }
+    removeDirectoryIfExists(path.join(rootDir, entry.name));
+  }
+}
+
+function cleanupLegacyRootFiles(binDir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(binDir, { withFileTypes: true });
+  } catch (_) {
+    return;
+  }
+
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    if (!/^rebon-.+\.exe$/i.test(entry.name)) {
+      continue;
+    }
+    try {
+      fs.unlinkSync(path.join(binDir, entry.name));
+    } catch (_) {
+    }
+  }
+}
+
+function cleanupOldVersions(binDir, keepVersionKey) {
+  cleanupDirectoryEntries(path.join(binDir, VERSIONS_DIR), keepVersionKey);
+  cleanupDirectoryEntries(path.join(binDir, STAGING_DIR), keepVersionKey);
+  cleanupLegacyRootFiles(binDir);
+}
+
+function promoteStagingDirectory(stagingDir, versionDir) {
+  fs.mkdirSync(path.dirname(versionDir), { recursive: true });
+  if (fs.existsSync(versionDir)) {
+    fs.rmSync(versionDir, { recursive: true, force: true });
+  }
+  fs.renameSync(stagingDir, versionDir);
+}
+
+function installToVersionKey(packageInfo, binDir, versionKey) {
+  const layout = layoutForVersion(binDir, versionKey);
+  resetDirectory(layout.stagingDir);
+  copyPayloadDirectory(packageInfo.payloadDir, layout.stagingDir);
+  promoteStagingDirectory(layout.stagingDir, layout.versionDir);
+
+  writeManifest(layout.manifestPath, {
+    version: packageInfo.version,
+    versionKey,
+    path: layout.manifestRelativePath,
+    package: packageInfo.name,
+    payload: packageInfo.payload || payloadSignature(packageInfo.payloadPath),
+    installedAt: new Date().toISOString(),
+  });
+  cleanupOldVersions(binDir, versionKey);
+  return layout.exePath;
+}
+
+function installManagedPackage(packageInfo) {
+  const binDir = managedBinDir();
+  if (!binDir || !fs.existsSync(packageInfo.payloadPath)) {
+    return null;
+  }
+
+  const installedManifest = readInstalledManifest(packageInfo);
+  if (installedManifest) {
+    cleanupOldVersions(binDir, installedManifest.versionKey);
+    return resolveManifestPath(binDir, installedManifest.path);
+  }
+
+  try {
+    return installToVersionKey(packageInfo, binDir, packageInfo.versionKey);
+  } catch (error) {
+    const fallbackVersionKey = payloadSpecificVersionKey(packageInfo);
+    if (fallbackVersionKey === packageInfo.versionKey) {
+      throw error;
+    }
+    return installToVersionKey(packageInfo, binDir, fallbackVersionKey);
+  }
+}
+
+function resolveExecutable(packageInfo) {
+  const info = packageInfo || readPackageInfo();
+  const installed = readInstalledExecutable(info);
+  if (installed) {
+    return { exe: installed, usedFallback: false, installError: null };
+  }
+
+  let installError = null;
+  try {
+    const managed = installManagedPackage(info);
+    if (managed) {
+      return { exe: managed, usedFallback: false, installError: null };
+    }
+  } catch (error) {
+    installError = error;
+  }
+
+  if (fs.existsSync(info.payloadPath)) {
+    return { exe: info.payloadPath, usedFallback: true, installError };
+  }
+
+  return { exe: null, usedFallback: false, installError };
+}
+
+function spawnResolvedExecutable(resolved, argv, spawnImpl) {
+  const child = spawnImpl(resolved.exe, argv, {
+    stdio: "inherit",
+    windowsHide: false,
+  });
+
+  child.on("error", (error) => {
+    console.error(`rebon: failed to start ${resolved.exe}: ${error.message}`);
+    process.exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      try {
+        process.kill(process.pid, signal);
+      } catch (_) {
+        process.exit(1);
+      }
+      return;
+    }
+    process.exit(code === null ? 1 : code);
+  });
+
+  return child;
+}
+
+module.exports = {
+  cleanupOldVersions,
+  installManagedPackage,
+  layoutForVersion,
+  managedBinDir,
+  managedRelativeExecutable,
+  payloadSignature,
+  readCurrentManifest,
+  readInstalledExecutable,
+  readPackageInfo,
+  requireManagedBinDir,
+  resolveExecutable,
+  spawnResolvedExecutable,
+  versionKeyFromPackageJson,
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@rebon/cli-win32-x64",
+  "version": "0.1.3",
+  "description": "Agent cli for coding and more.",
+  "license": "MIT OR Apache-2.0",
+  "bin": {
+    "rebon": "bin/rebon.js"
+  },
+  "files": [
+    "bin",
+    "README.md",
+    "scripts",
+    "payload",
+    "lib"
+  ],
+  "os": [
+    "win32"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  }
+}

package/scripts/postinstall.js

@@ -0,0 +1,112 @@
+"use strict";
+
+const childProcess = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const INSTALL_SUPERVISOR_ENV = "REBON_INSTALL_SUPERVISOR";
+
+function log(message) {
+  console.log(`[rebon postinstall] ${message}`);
+}
+
+function envFlagEnabled(value) {
+  return /^(1|true|yes|on)$/i.test(String(value || "").trim());
+}
+
+function supervisorHintMessage() {
+  return "background supervisor scheduler was not registered; run `rebon agents service install` to keep queued jobs moving after login, or set REBON_INSTALL_SUPERVISOR=1 before install to opt in.";
+}
+
+function packageRootFromScript() {
+  return path.resolve(__dirname, "..");
+}
+
+function installWindowsPayload(packageRoot) {
+  const {
+    installManagedPackage,
+    readPackageInfo,
+    requireManagedBinDir,
+  } = require("../lib/windows-managed");
+
+  requireManagedBinDir();
+  const packageInfo = readPackageInfo(packageRoot);
+  if (!fs.existsSync(packageInfo.payloadPath)) {
+    throw new Error(`payload executable is missing: ${packageInfo.payloadPath}`);
+  }
+
+  const managedExe = installManagedPackage(packageInfo);
+  if (!managedExe) {
+    throw new Error("could not install payload executable into managed bin directory");
+  }
+  return managedExe;
+}
+
+function packageExecutable(packageRoot, platform) {
+  if (platform === "win32") {
+    return installWindowsPayload(packageRoot);
+  }
+
+  const exePath = path.join(packageRoot, "bin", "rebon");
+  if (!fs.existsSync(exePath)) {
+    throw new Error(`payload executable is missing: ${exePath}`);
+  }
+
+  try {
+    fs.chmodSync(exePath, 0o755);
+  } catch (_) {
+  }
+  return exePath;
+}
+
+function installSupervisorScheduler(exePath, spawnSyncImpl) {
+  const result = spawnSyncImpl(exePath, ["agents", "service", "install"], {
+    stdio: "inherit",
+    windowsHide: true,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`supervisor scheduler install exited with status ${result.status}`);
+  }
+}
+
+function runPostinstall(options = {}) {
+  const platform = options.platform || process.platform;
+  const env = options.env || process.env;
+  const logger = options.log || log;
+  const spawnSyncImpl = options.spawnSync || childProcess.spawnSync;
+  const packageRoot = options.packageRoot || packageRootFromScript();
+  const exePath = packageExecutable(packageRoot, platform);
+
+  logger(`installed ${exePath}`);
+
+  if (envFlagEnabled(env[INSTALL_SUPERVISOR_ENV])) {
+    logger(`registering per-user background supervisor scheduler because ${INSTALL_SUPERVISOR_ENV} is enabled`);
+    installSupervisorScheduler(exePath, spawnSyncImpl);
+    logger("registered background supervisor scheduler");
+    return;
+  }
+
+  logger(supervisorHintMessage());
+}
+
+try {
+  if (require.main === module) {
+    runPostinstall();
+  }
+} catch (error) {
+  console.error(`[rebon postinstall] ${error.message}`);
+  process.exit(1);
+}
+
+module.exports = {
+  INSTALL_SUPERVISOR_ENV,
+  envFlagEnabled,
+  installSupervisorScheduler,
+  packageExecutable,
+  runPostinstall,
+  supervisorHintMessage,
+};