@solar_orb/agent_orb 0.1.0

package/README.md

@@ -0,0 +1,59 @@
+# agent_orb npx bootstrapper
+
+Local development bootstrapper for Agent Orb. It is intended to become:
+
+```bash
+npx @solar_orb/agent_orb
+```
+
+after the package is published to npm.
+
+## Local development
+
+From the repo root:
+
+```bash
+./scripts/release/smoke-npx-local.sh
+```
+
+For manual testing:
+
+```bash
+npm --prefix packages/agent_orb run package-runtime
+npx --yes ./packages/agent_orb setup --yes
+```
+
+If `packages/agent_orb/releases` contains a matching native bundle, setup installs that bundle directly with SHA256 verification. Otherwise it falls back to source build.
+
+## Windows local path
+
+```powershell
+cd C:\path\to\AgentOrb
+npx --yes .\packages\agent_orb
+```
+
+If no Windows bundle is present and Rust is not installed on Windows yet, setup will print:
+
+```powershell
+winget install --id Rustlang.Rustup -e
+```
+
+For the intended no-Rust Windows path, publish or place `agent-orb-windows-x64.zip` plus `checksums.txt` in the release endpoint/package releases directory.
+
+## Windows + WSL repo caveat
+
+Windows npm may fail with `ERR_INVALID_URL` when installing a local package directly from a UNC path like:
+
+```powershell
+\\wsl.localhost\Ubuntu\home\...\AgentOrb
+```
+
+For Windows-host testing, prefer either:
+
+1. run from a Windows-local clone, or
+2. use a packed tarball from a Windows-local directory:
+
+```powershell
+cd $env:TEMP\agent-orb-npx
+npx --yes .\agent_orb-0.1.0.tgz --help
+```

package/bin/agent_orb.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const entry = path.join(packageDir, 'dist', 'index.js');
+
+if (!existsSync(entry)) {
+  console.error('[agent_orb] bootstrapper build output is missing; building it now...');
+  const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+
+  const install = spawnSync(npm, ['install'], {
+    cwd: packageDir,
+    stdio: 'inherit',
+  });
+  if (install.status !== 0) process.exit(install.status ?? 1);
+
+  const build = spawnSync(npm, ['run', 'build'], {
+    cwd: packageDir,
+    stdio: 'inherit',
+  });
+  if (build.status !== 0) process.exit(build.status ?? 1);
+}
+
+await import(pathToFileURL(entry).href);

package/dist/adapter.js

@@ -0,0 +1,25 @@
+import { findCommand } from './shell.js';
+export const adapters = [
+    {
+        name: 'codex',
+        displayName: 'Codex CLI',
+        binaryCandidates: process.platform === 'win32' ? ['codex.exe', 'codex'] : ['codex'],
+        wrapperCommand: process.platform === 'win32' ? 'codex-orb.cmd' : 'codex-orb',
+        promptPatterns: ['approve', 'permission', 'continue?', 'yes/no'],
+    },
+    {
+        name: 'claude',
+        displayName: 'Claude Code CLI',
+        binaryCandidates: process.platform === 'win32' ? ['claude.exe', 'claude'] : ['claude'],
+        wrapperCommand: process.platform === 'win32' ? 'claude-orb.cmd' : 'claude-orb',
+        promptPatterns: ['continue?', 'permission', 'press enter', 'approve'],
+    },
+];
+export function detectAdapters() {
+    return adapters.map((adapter) => {
+        const found = adapter.binaryCandidates
+            .map((candidate) => findCommand(candidate))
+            .find((candidate) => candidate !== undefined);
+        return { ...adapter, foundBinary: found };
+    });
+}

package/dist/checksum.js

@@ -0,0 +1,27 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+export function sha256File(filePath) {
+    const hash = crypto.createHash('sha256');
+    hash.update(fs.readFileSync(filePath));
+    return hash.digest('hex');
+}
+export function parseChecksums(text) {
+    const checksums = new Map();
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const match = line.match(/^([a-fA-F0-9]{64})\s+\*?(.+)$/);
+        if (!match)
+            continue;
+        const [, checksum, filename] = match;
+        checksums.set(filename.trim(), checksum.toLowerCase());
+    }
+    return checksums;
+}
+export function verifyChecksum(filePath, expectedSha256) {
+    const actual = sha256File(filePath);
+    if (actual !== expectedSha256.toLowerCase()) {
+        throw new Error(`Checksum mismatch for ${filePath}\nexpected: ${expectedSha256}\nactual:   ${actual}`);
+    }
+}

package/dist/config.js

@@ -0,0 +1,20 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export function runtimeConfigFromEnv(env = process.env) {
+    const daemonPort = Number.parseInt(env.AGENT_ORB_DAEMON_PORT ?? '17321', 10);
+    if (!Number.isInteger(daemonPort) || daemonPort <= 0 || daemonPort > 65535) {
+        throw new Error(`Invalid AGENT_ORB_DAEMON_PORT: ${env.AGENT_ORB_DAEMON_PORT}`);
+    }
+    return {
+        daemonHost: env.AGENT_ORB_DAEMON_HOST ?? '127.0.0.1',
+        daemonPort,
+    };
+}
+export function writeConfig(configDir, selectedAdapters, runtime = runtimeConfigFromEnv()) {
+    fs.mkdirSync(configDir, { recursive: true });
+    const configPath = path.join(configDir, 'config.toml');
+    const enabled = new Set(selectedAdapters.map((adapter) => adapter.name));
+    const content = `# Generated by npx agent_orb\n\n[install]\nmethod = "npx"\nversion = "0.1.0"\n\n[adapters.codex]\nenabled = ${enabled.has('codex')}\nbinary = "codex"\nwrapper = "codex-orb"\n\n[adapters.claude]\nenabled = ${enabled.has('claude')}\nbinary = "claude"\nwrapper = "claude-orb"\n\n[daemon]\nhost = "${runtime.daemonHost}"\nport = ${runtime.daemonPort}\nauto_start = true\n\n[orb]\nposition = "top-right"\nsize = 36\nopacity = 0.88\nalways_on_top = true\nclick_through = false\n\n[colors]\ndisconnected = "#6B7280"\nidle = "#9CA3AF"\nstarting = "#60A5FA"\nactive = "#3B82F6"\nthinking_like = "#8B5CF6"\nwaiting_input = "#FBBF24"\ncompleted = "#22C55E"\nerror = "#EF4444"\nwarning = "#F97316"\n\n[behavior]\nsilent_threshold_seconds = 20\nstuck_threshold_seconds = 180\ncompleted_hold_seconds = 10\nerror_requires_click_to_clear = true\n\n[privacy]\ninclude_output_sample = false\nmax_sample_chars = 512\n`;
+    fs.writeFileSync(configPath, content, 'utf8');
+    return configPath;
+}

package/dist/download.js

@@ -0,0 +1,201 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { parseChecksums, verifyChecksum } from './checksum.js';
+import { run } from './shell.js';
+export async function installRuntimeBundle(platform, options = {}) {
+    if (!options.force && runtimeLooksInstalled(platform)) {
+        console.log('\n==> Runtime bundle');
+        console.log(`✓ existing runtime found at ${platform.runtimeDir}`);
+        return true;
+    }
+    const baseUrl = releaseBaseUrl(platform, options);
+    if (!baseUrl)
+        return false;
+    console.log('\n==> Downloading runtime bundle');
+    console.log(`Release base: ${baseUrl}`);
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-orb-runtime-'));
+    try {
+        const bundlePath = path.join(tempDir, platform.bundleName);
+        const checksumsPath = path.join(tempDir, 'checksums.txt');
+        await downloadFile(joinUrl(baseUrl, platform.bundleName), bundlePath);
+        await downloadFile(joinUrl(baseUrl, 'checksums.txt'), checksumsPath);
+        const checksums = parseChecksums(fs.readFileSync(checksumsPath, 'utf8'));
+        const expected = checksums.get(platform.bundleName);
+        if (!expected) {
+            throw new Error(`checksums.txt does not contain an entry for ${platform.bundleName}`);
+        }
+        verifyChecksum(bundlePath, expected);
+        console.log(`✓ checksum verified: ${platform.bundleName}`);
+        extractBundle(bundlePath, tempDir, platform);
+        writeInstallManifest(platform, {
+            bundle: platform.bundleName,
+            sha256: expected,
+            source: baseUrl,
+        });
+        console.log(`✓ installed runtime bundle into ${platform.runtimeDir}`);
+        return true;
+    }
+    finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+}
+export function runtimeLooksInstalled(platform) {
+    const required = ['agent_orb', 'agent_orbd'].map((name) => path.join(platform.runtimeDir, `${name}${platform.exeSuffix}`));
+    return required.every((file) => fs.existsSync(file));
+}
+function releaseBaseUrl(platform, options) {
+    if (options.releaseDir) {
+        return pathToFileURL(path.resolve(options.releaseDir)).href;
+    }
+    if (options.releaseBaseUrl) {
+        return normalizeBase(options.releaseBaseUrl);
+    }
+    if (process.env.AGENT_ORB_RELEASE_DIR) {
+        return pathToFileURL(path.resolve(process.env.AGENT_ORB_RELEASE_DIR)).href;
+    }
+    const configured = process.env.AGENT_ORB_RELEASE_BASE_URL ?? process.env.AGENT_ORB_RELEASE_URL;
+    if (configured?.trim())
+        return configured.trim().replace(/\/+$/, '');
+    const bundled = bundledReleaseBaseUrl(platform);
+    if (bundled)
+        return bundled;
+    const version = process.env.AGENT_ORB_VERSION ?? 'v0.1.0';
+    const repo = githubRepository();
+    if (repo)
+        return `https://github.com/${repo}/releases/download/${version}`;
+    return undefined;
+}
+function githubRepository() {
+    const configured = process.env.AGENT_ORB_GITHUB_REPOSITORY;
+    if (configured?.trim())
+        return configured.trim();
+    const packageRepo = process.env.npm_package_config_github_repository;
+    if (packageRepo?.trim())
+        return packageRepo.trim();
+    const ownPackageRepo = readPackageGithubRepository();
+    if (ownPackageRepo)
+        return ownPackageRepo;
+    return undefined;
+}
+function readPackageGithubRepository() {
+    try {
+        const packageJsonPath = fileURLToPath(new URL('../package.json', import.meta.url));
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const repo = packageJson.config?.github_repository;
+        return typeof repo === 'string' && repo.trim() ? repo.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function bundledReleaseBaseUrl(platform) {
+    const releaseDir = fileURLToPath(new URL('../releases/', import.meta.url));
+    if (fs.existsSync(path.join(releaseDir, platform.bundleName)) &&
+        fs.existsSync(path.join(releaseDir, 'checksums.txt'))) {
+        return pathToFileURL(releaseDir).href;
+    }
+    return undefined;
+}
+async function downloadFile(url, dest) {
+    console.log(`↓ ${url}`);
+    if (url.startsWith('file:')) {
+        fs.copyFileSync(fileURLToPath(url), dest);
+        return;
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Download failed (${response.status} ${response.statusText}): ${url}`);
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    fs.writeFileSync(dest, bytes);
+}
+function writeInstallManifest(platform, manifest) {
+    fs.mkdirSync(platform.runtimeDir, { recursive: true });
+    const manifestPath = path.join(platform.runtimeDir, 'agent-orb-runtime.json');
+    fs.writeFileSync(manifestPath, `${JSON.stringify({
+        install_method: 'npx',
+        installed_at: new Date().toISOString(),
+        ...manifest,
+    }, null, 2)}\n`, 'utf8');
+}
+function extractBundle(bundlePath, tempDir, platform) {
+    const extractDir = path.join(tempDir, 'extract');
+    fs.mkdirSync(extractDir, { recursive: true });
+    if (platform.platform === 'windows') {
+        run('tar', ['-xf', bundlePath, '-C', extractDir]);
+    }
+    else {
+        run('tar', ['-xzf', bundlePath, '-C', extractDir]);
+    }
+    fs.mkdirSync(platform.runtimeDir, { recursive: true });
+    const binDir = findExtractedBinDir(extractDir, platform);
+    copyRuntimeFile(binDir, platform.runtimeDir, `agent_orb${platform.exeSuffix}`, platform);
+    copyRuntimeFile(binDir, platform.runtimeDir, `agent_orbd${platform.exeSuffix}`, platform);
+    copyOptionalRuntimeFile(binDir, platform.runtimeDir, `agent-orb-ui${platform.exeSuffix}`, platform);
+}
+function findExtractedBinDir(extractDir, platform) {
+    const candidates = [
+        extractDir,
+        path.join(extractDir, 'bin'),
+        path.join(extractDir, 'agent-orb'),
+        path.join(extractDir, 'agent-orb', 'bin'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(path.join(candidate, `agent_orb${platform.exeSuffix}`))) {
+            return candidate;
+        }
+    }
+    throw new Error(`Bundle does not contain agent_orb${platform.exeSuffix}`);
+}
+function copyRuntimeFile(sourceDir, destDir, filename, platform) {
+    const source = path.join(sourceDir, filename);
+    if (!fs.existsSync(source))
+        throw new Error(`Bundle is missing required file: ${filename}`);
+    copyFile(source, path.join(destDir, filename), platform);
+}
+function copyOptionalRuntimeFile(sourceDir, destDir, filename, platform) {
+    const source = path.join(sourceDir, filename);
+    if (fs.existsSync(source))
+        copyFile(source, path.join(destDir, filename), platform);
+}
+function copyFile(source, dest, platform) {
+    const temp = path.join(path.dirname(dest), `.${path.basename(dest)}.${process.pid}.tmp`);
+    fs.copyFileSync(source, temp);
+    if (platform.platform !== 'windows')
+        fs.chmodSync(temp, 0o755);
+    try {
+        fs.renameSync(temp, dest);
+    }
+    catch (error) {
+        fs.rmSync(temp, { force: true });
+        if (platform.platform === 'windows') {
+            throw new Error(`Could not replace ${dest}. Stop agent_orbd.exe / agent-orb-ui.exe and rerun npx agent_orb. Original error: ${formatError(error)}`);
+        }
+        throw error;
+    }
+}
+function joinUrl(base, name) {
+    const normalized = normalizeBase(base);
+    if (normalized.startsWith('file:')) {
+        return new URL(encodeURIComponent(name), ensureTrailingSlash(normalized)).href;
+    }
+    return `${normalized.replace(/\/+$/, '')}/${encodeURIComponent(name)}`;
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function normalizeBase(value) {
+    const trimmed = value.trim();
+    if (/^https?:\/\//i.test(trimmed) || /^file:\/\//i.test(trimmed)) {
+        return trimmed.replace(/\/+$/, '');
+    }
+    if (fs.existsSync(trimmed)) {
+        return pathToFileURL(path.resolve(trimmed)).href;
+    }
+    return trimmed.replace(/\/+$/, '');
+}
+function ensureTrailingSlash(value) {
+    return value.endsWith('/') ? value : `${value}/`;
+}

package/dist/index.js

@@ -0,0 +1,82 @@
+import { doctor, setup } from './setup.js';
+async function main() {
+    const args = process.argv.slice(2);
+    const command = parseCommand(args);
+    const flags = new Set(args.filter((arg) => arg.startsWith('-')));
+    switch (command) {
+        case 'setup':
+            if (flags.has('--help') || flags.has('-h')) {
+                printHelp();
+                break;
+            }
+            await setup({
+                yes: flags.has('--yes') || flags.has('-y'),
+                smoke: !flags.has('--no-smoke'),
+                force: flags.has('--force'),
+                buildFromSource: flags.has('--build-from-source'),
+                releaseBaseUrl: flagValue(args, '--release-base-url'),
+                releaseDir: flagValue(args, '--release-dir'),
+            });
+            break;
+        case 'doctor':
+            await doctor();
+            break;
+        case 'version':
+        case '--version':
+        case '-v':
+            console.log('agent_orb bootstrapper 0.1.0');
+            break;
+        case 'help':
+        case '--help':
+        case '-h':
+            printHelp();
+            break;
+        default:
+            throw new Error(`Unknown command: ${command}`);
+    }
+}
+function parseCommand(args) {
+    const first = args[0];
+    if (!first)
+        return 'setup';
+    if (first === '--help' || first === '-h')
+        return 'help';
+    if (first === '--version' || first === '-v')
+        return 'version';
+    if (first.startsWith('-'))
+        return 'setup';
+    return first;
+}
+function flagValue(args, name) {
+    const equalsPrefix = `${name}=`;
+    const inline = args.find((arg) => arg.startsWith(equalsPrefix));
+    if (inline)
+        return inline.slice(equalsPrefix.length);
+    const index = args.indexOf(name);
+    if (index >= 0)
+        return args[index + 1];
+    return undefined;
+}
+function printHelp() {
+    console.log(`Agent Orb bootstrapper
+
+Usage:
+  agent_orb [setup] [--yes] [--no-smoke] [--force]
+            [--release-dir <dir> | --release-base-url <url>]
+            [--build-from-source]
+  agent_orb doctor
+  agent_orb version
+
+Local development:
+  ./scripts/release/smoke-npx-local.sh
+  npx --yes ./packages/agent_orb setup --yes
+
+After npm publish:
+  npx @solar_orb/agent_orb
+`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`agent_orb setup failed: ${message}`);
+    process.exit(1);
+});

package/dist/platform.js

@@ -0,0 +1,62 @@
+import os from 'node:os';
+export function detectPlatform(env = process.env) {
+    const platform = detectPlatformName();
+    const arch = detectArchName();
+    const exeSuffix = platform === 'windows' ? '.exe' : '';
+    const pathDelimiter = platform === 'windows' ? ';' : ':';
+    const runtimeDir = defaultRuntimeDir(platform, env);
+    const configDir = defaultConfigDir(platform, env);
+    const bundleName = `agent-orb-${platform}-${arch}${platform === 'windows' ? '.zip' : '.tar.gz'}`;
+    return { platform, arch, exeSuffix, pathDelimiter, runtimeDir, configDir, bundleName };
+}
+function detectPlatformName() {
+    switch (process.platform) {
+        case 'win32':
+            return 'windows';
+        case 'darwin':
+            return 'macos';
+        case 'linux':
+            return 'linux';
+        default:
+            return 'unsupported';
+    }
+}
+function detectArchName() {
+    switch (os.arch()) {
+        case 'x64':
+            return 'x64';
+        case 'arm64':
+            return 'arm64';
+        default:
+            return 'unsupported';
+    }
+}
+function defaultRuntimeDir(platform, env) {
+    if (env.AGENT_ORB_BIN_DIR)
+        return env.AGENT_ORB_BIN_DIR;
+    if (platform === 'windows') {
+        const localAppData = env.LOCALAPPDATA ?? env.USERPROFILE ?? process.cwd();
+        return `${localAppData}\\agent-orb\\bin`;
+    }
+    if (platform === 'macos') {
+        const home = env.HOME ?? process.cwd();
+        return `${home}/Library/Application Support/agent-orb/bin`;
+    }
+    const home = env.HOME ?? process.cwd();
+    return `${home}/.local/share/agent-orb/bin`;
+}
+function defaultConfigDir(platform, env) {
+    if (env.AGENT_ORB_CONFIG_DIR)
+        return env.AGENT_ORB_CONFIG_DIR;
+    if (platform === 'windows') {
+        const appData = env.APPDATA ?? env.USERPROFILE ?? process.cwd();
+        return `${appData}\\agent-orb`;
+    }
+    if (platform === 'macos') {
+        const home = env.HOME ?? process.cwd();
+        return `${home}/Library/Application Support/agent-orb`;
+    }
+    const xdg = env.XDG_CONFIG_HOME;
+    const home = env.HOME ?? process.cwd();
+    return `${xdg ?? `${home}/.config`}/agent-orb`;
+}

package/dist/setup.js

@@ -0,0 +1,298 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { detectAdapters } from './adapter.js';
+import { runtimeConfigFromEnv, writeConfig } from './config.js';
+import { installRuntimeBundle } from './download.js';
+import { detectPlatform } from './platform.js';
+import { commandExists, run, spawnDetached } from './shell.js';
+export async function setup(options = {}) {
+    const platform = detectPlatform();
+    const runtime = runtimeConfigFromEnv();
+    printHeader(platform);
+    assertSupported(platform);
+    if (options.doctorOnly) {
+        await doctor(platform, runtime);
+        return;
+    }
+    console.log(`Runtime dir: ${platform.runtimeDir}`);
+    console.log(`Config dir:  ${platform.configDir}`);
+    const detectedAdapters = detectAdapters();
+    printDetectedAdapters(detectedAdapters);
+    const selectedAdapters = await selectAdapters(detectedAdapters, options.yes);
+    if (options.buildFromSource) {
+        installRuntimeFromSource(platform);
+    }
+    else {
+        const installedFromBundle = await installRuntimeBundle(platform, {
+            force: options.force,
+            releaseBaseUrl: options.releaseBaseUrl,
+            releaseDir: options.releaseDir,
+        });
+        if (!installedFromBundle) {
+            console.log('\n· No matching native runtime bundle was found for this platform.');
+            console.log('· Falling back to local source build.');
+            installRuntimeFromSource(platform);
+        }
+    }
+    const configPath = writeConfig(platform.configDir, selectedAdapters, runtime);
+    createAdapterShims(platform, selectedAdapters);
+    ensurePathHint(platform);
+    await ensureDaemon(platform, runtime);
+    if (options.smoke ?? true) {
+        smokeTest(platform);
+    }
+    console.log('\n✓ Agent Orb setup complete');
+    console.log(`Config: ${configPath}`);
+    console.log(`Try:    ${runtimeExe(platform, 'agent_orb')} run -- ${platform.platform === 'windows' ? 'cmd /C echo hello' : 'echo hello'}`);
+    const orb = runtimeExe(platform, 'agent-orb-ui');
+    if (fs.existsSync(orb)) {
+        console.log(`Orb:    ${orb}`);
+    }
+}
+function installRuntimeFromSource(platform) {
+    console.log('\n==> Building runtime from source');
+    ensureBuildTools();
+    const repoRoot = findRepoRoot();
+    console.log(`Repository: ${repoRoot}`);
+    buildRuntime(repoRoot);
+    installRuntime(repoRoot, platform);
+}
+export async function doctor(platform = detectPlatform(), runtime = runtimeConfigFromEnv()) {
+    printHeader(platform);
+    assertSupported(platform);
+    const binaries = ['agent_orb', 'agent_orbd'].map((name) => runtimeExe(platform, name));
+    for (const binary of binaries) {
+        console.log(`${fs.existsSync(binary) ? '✓' : '✗'} ${binary}`);
+    }
+    console.log(`${fs.existsSync(path.join(platform.configDir, 'token')) ? '✓' : '·'} token: ${path.join(platform.configDir, 'token')}`);
+    console.log(`${await health(runtime) ? '✓' : '·'} daemon: http://${runtime.daemonHost}:${runtime.daemonPort}/health`);
+    printDetectedAdapters(detectAdapters());
+}
+function printHeader(platform) {
+    console.log('Agent Orb Setup');
+    console.log(`Platform: ${platform.platform}/${platform.arch}`);
+    console.log(`Bundle:   ${platform.bundleName}`);
+}
+function assertSupported(platform) {
+    if (platform.platform === 'unsupported' || platform.arch === 'unsupported') {
+        throw new Error(`Unsupported platform: ${process.platform}/${process.arch}`);
+    }
+}
+function ensureBuildTools() {
+    if (!commandExists('cargo') || !commandExists('rustc')) {
+        const install = process.platform === 'win32'
+            ? 'winget install --id Rustlang.Rustup -e'
+            : 'curl https://sh.rustup.rs -sSf | sh';
+        throw new Error(`Rust toolchain is required for local npx setup. Install it first:\n  ${install}`);
+    }
+}
+function buildRuntime(repoRoot) {
+    console.log('\n==> Building Agent Orb runtime');
+    run('cargo', ['build', '--release', '-p', 'agent-orb-cli', '-p', 'agent-orb-daemon'], {
+        cwd: repoRoot,
+        stdio: 'inherit',
+    });
+}
+function installRuntime(repoRoot, platform) {
+    console.log('\n==> Installing runtime');
+    fs.mkdirSync(platform.runtimeDir, { recursive: true });
+    copyRequired(repoRoot, platform, 'agent_orb');
+    copyRequired(repoRoot, platform, 'agent_orbd');
+    const uiBinary = path.join(repoRoot, 'apps', 'agent-orb-ui', 'src-tauri', 'target', 'release', `agent-orb-ui${platform.exeSuffix}`);
+    if (fs.existsSync(uiBinary)) {
+        fs.copyFileSync(uiBinary, path.join(platform.runtimeDir, `agent-orb-ui${platform.exeSuffix}`));
+        console.log(`✓ installed agent-orb-ui${platform.exeSuffix}`);
+    }
+    else {
+        console.log('· UI binary not found, skipping UI install for now');
+    }
+}
+function copyRequired(repoRoot, platform, name) {
+    const source = path.join(repoRoot, 'target', 'release', `${name}${platform.exeSuffix}`);
+    if (!fs.existsSync(source)) {
+        throw new Error(`Build output not found: ${source}`);
+    }
+    const dest = path.join(platform.runtimeDir, `${name}${platform.exeSuffix}`);
+    if (sameFileContent(source, dest)) {
+        console.log(`✓ ${dest} already up to date`);
+        return;
+    }
+    copyBinaryReplacingExisting(source, dest, platform);
+    console.log(`✓ installed ${dest}`);
+}
+function sameFileContent(left, right) {
+    if (!fs.existsSync(left) || !fs.existsSync(right))
+        return false;
+    const leftStat = fs.statSync(left);
+    const rightStat = fs.statSync(right);
+    if (leftStat.size !== rightStat.size)
+        return false;
+    return fs.readFileSync(left).equals(fs.readFileSync(right));
+}
+function copyBinaryReplacingExisting(source, dest, platform) {
+    const temp = path.join(path.dirname(dest), `.${path.basename(dest)}.${process.pid}.tmp`);
+    fs.copyFileSync(source, temp);
+    if (platform.platform !== 'windows')
+        fs.chmodSync(temp, 0o755);
+    try {
+        fs.renameSync(temp, dest);
+    }
+    catch (error) {
+        fs.rmSync(temp, { force: true });
+        if (platform.platform === 'windows') {
+            throw new Error(`Could not replace ${dest}. If Agent Orb is already running, stop agent_orbd.exe / agent-orb-ui.exe and rerun npx agent_orb. Original error: ${formatError(error)}`);
+        }
+        throw error;
+    }
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function selectAdapters(adapters, yes = false) {
+    if (yes) {
+        return adapters.filter((adapter) => adapter.foundBinary);
+    }
+    const found = adapters.filter((adapter) => adapter.foundBinary);
+    if (found.length === 0) {
+        console.log('No Codex/Claude CLI detected. Manual agent_orb run remains available.');
+        return [];
+    }
+    if (!process.stdin.isTTY) {
+        return found;
+    }
+    const rl = readline.createInterface({ input, output });
+    const choices = found.map((adapter, index) => `${index + 1}) ${adapter.displayName}`).join('\n');
+    const answer = await rl.question(`\nChoose adapters to configure (comma-separated, Enter = all):\n${choices}\n> `);
+    rl.close();
+    if (!answer.trim())
+        return found;
+    const selectedIndexes = new Set(answer.split(',').map((part) => Number.parseInt(part.trim(), 10) - 1));
+    return found.filter((_, index) => selectedIndexes.has(index));
+}
+function printDetectedAdapters(adapters) {
+    console.log('\nDetected adapters:');
+    for (const adapter of adapters) {
+        if (adapter.foundBinary) {
+            console.log(`  ✓ ${adapter.displayName}: ${adapter.foundBinary}`);
+        }
+        else {
+            console.log(`  · ${adapter.displayName}: not found`);
+        }
+    }
+}
+function createAdapterShims(platform, adapters) {
+    if (adapters.length === 0)
+        return;
+    console.log('\n==> Creating adapter shims');
+    for (const adapter of adapters) {
+        const shimPath = path.join(platform.runtimeDir, adapter.wrapperCommand);
+        if (platform.platform === 'windows') {
+            const target = adapter.name;
+            fs.writeFileSync(shimPath, `@echo off\r\n"%~dp0agent_orb.exe" run -- ${target} %*\r\n`, 'ascii');
+        }
+        else {
+            fs.writeFileSync(shimPath, `#!/usr/bin/env sh\n"$(dirname "$0")/agent_orb" run -- ${adapter.name} "$@"\n`, 'utf8');
+            fs.chmodSync(shimPath, 0o755);
+        }
+        console.log(`✓ ${shimPath}`);
+    }
+}
+function ensurePathHint(platform) {
+    const currentPath = process.env.PATH ?? '';
+    const parts = currentPath.split(platform.pathDelimiter).filter(Boolean);
+    if (parts.includes(platform.runtimeDir))
+        return;
+    console.log('\nPATH note:');
+    if (platform.platform === 'windows') {
+        console.log(`  Add to user PATH if needed: ${platform.runtimeDir}`);
+        console.log('  Or open a new terminal if installer/script already added it.');
+    }
+    else {
+        console.log(`  export PATH="${platform.runtimeDir}:$PATH"`);
+    }
+}
+async function ensureDaemon(platform, runtime) {
+    console.log('\n==> Starting daemon');
+    const tokenPath = path.join(platform.configDir, 'token');
+    if (fs.existsSync(tokenPath) && await authenticatedStatus(tokenPath, runtime)) {
+        console.log(`✓ daemon already healthy at http://${runtime.daemonHost}:${runtime.daemonPort}/health`);
+        return;
+    }
+    const daemon = runtimeExe(platform, 'agent_orbd');
+    const daemonAlreadyHealthy = await health(runtime);
+    if (daemonAlreadyHealthy) {
+        throw new Error(`agent_orbd is already running on ${runtime.daemonHost}:${runtime.daemonPort}, but it does not accept the token at ${tokenPath}. Stop the existing agent_orbd process and rerun setup.`);
+    }
+    const pid = spawnDetached(daemon, []);
+    if (pid) {
+        fs.mkdirSync(platform.configDir, { recursive: true });
+        fs.writeFileSync(path.join(platform.configDir, 'daemon.pid'), `${pid}\n`, 'utf8');
+    }
+    for (let i = 0; i < 40; i++) {
+        if (fs.existsSync(tokenPath) && await authenticatedStatus(tokenPath, runtime)) {
+            console.log(`✓ daemon healthy at http://${runtime.daemonHost}:${runtime.daemonPort}/health`);
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(`daemon did not become healthy on ${runtime.daemonHost}:${runtime.daemonPort}`);
+}
+async function health(runtime) {
+    try {
+        const response = await fetch(`http://${runtime.daemonHost}:${runtime.daemonPort}/health`);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+async function authenticatedStatus(tokenPath, runtime) {
+    try {
+        const token = fs.readFileSync(tokenPath, 'utf8').trim();
+        if (!token)
+            return false;
+        const response = await fetch(`http://${runtime.daemonHost}:${runtime.daemonPort}/v1/status`, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+function smokeTest(platform) {
+    console.log('\n==> Smoke test');
+    const agentOrb = runtimeExe(platform, 'agent_orb');
+    if (platform.platform === 'windows') {
+        run(agentOrb, ['run', '--', 'cmd', '/C', 'echo', 'hello'], { stdio: 'inherit' });
+    }
+    else {
+        run(agentOrb, ['run', '--', 'echo', 'hello'], { stdio: 'inherit' });
+    }
+}
+function runtimeExe(platform, name) {
+    return path.join(platform.runtimeDir, `${name}${platform.exeSuffix}`);
+}
+function findRepoRoot() {
+    if (process.env.AGENT_ORB_REPO)
+        return process.env.AGENT_ORB_REPO;
+    let current = process.cwd();
+    for (;;) {
+        if (fs.existsSync(path.join(current, 'Cargo.toml')) && fs.existsSync(path.join(current, 'crates'))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    const fromPackage = path.resolve(fileURLToPath(new URL('../../..', import.meta.url)));
+    if (fs.existsSync(path.join(fromPackage, 'Cargo.toml')))
+        return fromPackage;
+    throw new Error('Could not find AgentOrb repo root. Set AGENT_ORB_REPO to the repo path.');
+}

package/dist/shell.js

@@ -0,0 +1,80 @@
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+export function commandExists(command) {
+    return findCommand(command) !== undefined;
+}
+export function findCommand(command) {
+    const pathEnv = process.env.PATH ?? '';
+    const searchDirs = pathEnv.split(process.platform === 'win32' ? ';' : ':').filter(Boolean);
+    const candidates = process.platform === 'win32'
+        ? commandCandidates(command)
+        : [command];
+    for (const dir of searchDirs) {
+        for (const candidate of candidates) {
+            const fullPath = path.join(dir, candidate);
+            if (isExecutableFile(fullPath))
+                return fullPath;
+        }
+    }
+    return undefined;
+}
+export function run(command, args, options = {}) {
+    const result = spawnSync(command, args, {
+        cwd: options.cwd,
+        env: options.env,
+        stdio: options.stdio ?? 'pipe',
+        encoding: 'utf8',
+    });
+    if (result.error)
+        throw result.error;
+    const status = result.status ?? 1;
+    if (status !== 0 && !options.allowFailure) {
+        throw new Error(`Command failed (${status}): ${command} ${args.join(' ')}\n${result.stderr ?? ''}`);
+    }
+    return {
+        status,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+    };
+}
+export function spawnDetached(command, args, cwd) {
+    const child = spawn(command, args, {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+    child.unref();
+    return child.pid;
+}
+function commandCandidates(command) {
+    if (path.extname(command))
+        return [command];
+    const pathExt = process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD';
+    return [
+        command,
+        ...pathExt
+            .split(';')
+            .filter(Boolean)
+            .map((extension) => `${command}${extension.toLowerCase()}`),
+        ...pathExt
+            .split(';')
+            .filter(Boolean)
+            .map((extension) => `${command}${extension.toUpperCase()}`),
+    ];
+}
+function isExecutableFile(filePath) {
+    try {
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile())
+            return false;
+        if (process.platform === 'win32')
+            return true;
+        fs.accessSync(filePath, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@solar_orb/agent_orb",
+  "version": "0.1.0",
+  "description": "Agent Orb local bootstrapper",
+  "type": "module",
+  "config": {
+    "github_repository": "SolarPetal/AgentOrb"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "agent_orb": "bin/agent_orb.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "check": "tsc --noEmit",
+    "package-runtime": "../../scripts/release/package-runtime.sh ../../dist/release-local",
+    "prepare": "npm run build",
+    "prepack": "npm run build",
+    "start": "node bin/agent_orb.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.0.0"
+  }
+}