omnara 0.5.2 → 0.6.0

package/dist/daemon/machine-supervisor.d.ts

@@ -42,6 +42,8 @@ export declare class MachineSupervisor {
     private runWebsocket;
     private handleSocketMessage;
     private handleRpcRequest;
+    private handleStartSession;
+    private handleStopSession;
     private sendRpcResponse;
     private launchWorkspaceSessionFromRpc;
     private launchWorkspaceSession;

package/dist/daemon/session-runner.d.ts

@@ -25,4 +25,14 @@ export declare class SessionManager {
     private readonly logger;
     constructor(options: SessionManagerOptions);
     startSession(spec: SessionLaunchSpec): Promise<void>;
+    /**
+     * Stop a running session by user session ID.
+     *
+     * Looks up the session in the PID registry, sends SIGTERM for graceful
+     * shutdown, waits briefly, then sends SIGKILL if still alive.
+     *
+     * @returns true if a running session was found and terminated, false if
+     *          the session was not running.
+     */
+    stopSession(userSessionId: string): Promise<boolean>;
 }

package/dist/orchestrator/ai-client.d.ts

@@ -18,6 +18,7 @@ export declare const BASE_ALLOWED_WORKER_TOOLS: readonly ["Task", "Bash", "Glob"
 export declare class AIClient implements AgentClient {
     private baseOptions;
     private query?;
+    private abortController?;
     private currentModel;
     constructor(config?: AIClientConfig);
     streamUserMessage(prompt: string | AsyncIterable<SDKUserMessage>, overrides?: Partial<Options>): AsyncIterable<SDKMessage>;

package/dist/orchestrator/orchestrator-prompt.d.ts

@@ -4,5 +4,5 @@
  * The orchestrator's role is to coordinate and delegate work, not to execute tasks directly.
  * It should ALWAYS use workers to handle all implementation work.
  */
-declare const ORCHESTRATOR_SYSTEM_PROMPT: string;
+import ORCHESTRATOR_SYSTEM_PROMPT from './orchestrator-prompt.md';
 export { ORCHESTRATOR_SYSTEM_PROMPT };

package/dist/orchestrator/session.d.ts

@@ -37,6 +37,7 @@ export declare class Session implements AsyncIterable<SDKUserMessage> {
     private sessionInitSubscribers;
     private queue;
     private generating;
+    private waitingForMessage;
     private announcementPromise;
     private announced;
     private shouldSummarize;

package/dist/package-info.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Package information constants.
+ *
+ * These are replaced at build time by esbuild/bun with values from package.json.
+ * The build process uses --define flags to replace __PACKAGE_* constants.
+ *
+ * In bundled context: Constants are replaced with literal strings at compile time.
+ * In dev context: Falls back to default values (actual version comes from build).
+ */
 export declare const PACKAGE_NAME: string;
 export declare const PACKAGE_VERSION: string;
 export declare const PACKAGE_DESCRIPTION: string;

package/dist/utils/claude-code-check.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Finds the path to the Claude Code executable.
+ *
+ * When running from a Bun single-file executable, the SDK's default resolution
+ * fails because it looks for cli.js relative to the bundled module location,
+ * which points to Bun's virtual filesystem (/$bunfs/root/cli.js).
+ *
+ * For Bun SFE, we MUST find the real claude executable via `which`.
+ * For Node.js, we can let the SDK handle it (return empty object).
+ */
+export declare function claudeExecutablePath(): {
+    pathToClaudeCodeExecutable?: string;
+};
 /**
  * Performs the Claude Code check and displays warning if needed
  * @param options - Optional configuration for the check

package/dist/utils/executable.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Utilities for handling Bun single-file executable (SFE) detection and spawning.
+ *
+ * BACKGROUND (from Bun docs and GitHub issues):
+ * When Bun compiles a script into a single-file executable, it creates a virtual
+ * filesystem at /$bunfs/root/ where the embedded code lives. This means:
+ *
+ * When running as a Bun SFE:
+ *   - process.execPath = /path/to/omnara (the compiled binary)
+ *   - process.argv[0] = "bun"
+ *   - process.argv[1] = "/$bunfs/root/omnara-darwin-arm64" (virtual filesystem path)
+ *
+ * When running via Node.js or `bun run`:
+ *   - process.execPath = /usr/bin/node or /path/to/bun
+ *   - process.argv[0] = same as execPath
+ *   - process.argv[1] = /path/to/cli.js (the actual script file)
+ *
+ * KEY INSIGHT (from Jarred Sumner, Bun team):
+ * - For the executable path, use `process.execPath`
+ * - The /$bunfs/ path is NOT a usable filesystem location
+ *
+ * DETECTION:
+ * Check if process.argv[1] starts with "/$bunfs/" to detect SFE mode.
+ *
+ * SPAWNING:
+ * In SFE mode: spawn(process.execPath, ['daemon', 'run-service'])
+ * In script mode: spawn(process.execPath, [process.argv[1], 'daemon', 'run-service'])
+ *
+ * References:
+ * - https://bun.com/docs/bundler/executables
+ * - https://github.com/oven-sh/bun/issues/8476
+ */
+/**
+ * Detects if running as a Bun single-file executable.
+ * In Bun SFE, process.argv[1] points to Bun's virtual filesystem (/$bunfs/root/...).
+ *
+ * This is the official detection method per Bun documentation and GitHub issues.
+ */
+export declare function isBunSingleFileExecutable(): boolean;
+/**
+ * Gets the arguments needed to spawn a new instance of this CLI.
+ * For Bun SFE, returns just the command args.
+ * For Node.js, prepends the script path.
+ *
+ * @param commandArgs - The CLI command and arguments (e.g., ['daemon', 'run-service'])
+ * @returns The full args array to pass to spawn(process.execPath, args)
+ */
+export declare function getSpawnArgs(commandArgs: string[]): string[];
+/**
+ * Gets the executable path for spawning a new instance of this CLI.
+ * Always returns process.execPath (works for both Node.js and Bun SFE).
+ */
+export declare function getExecutablePath(): string;

package/dist/utils/version-check.d.ts

@@ -1,5 +1,43 @@
+export declare const IS_PRERELEASE: boolean;
 /**
- * Checks if a newer version is available and logs a message if so.
- * This function is non-blocking and will not throw errors.
+ * Detects if the CLI was installed via npm (not as a standalone binary).
+ */
+export declare function isNpmInstallation(): boolean;
+/**
+ * Runs the installation script to install/update the binary version.
+ * Returns true if installation succeeded.
+ * Passes PRERELEASE=1 env var to install script if in prerelease mode.
+ *
+ * @param options.silent - If true, suppress output (for daemon background updates)
+ */
+export declare function runInstallScript(options?: {
+    silent?: boolean;
+}): Promise<boolean>;
+/**
+ * Checks if an update is available.
+ * Checks prerelease channel if PRERELEASE=1 env var is set.
+ */
+export declare function checkForUpdate(): Promise<{
+    available: boolean;
+    latestVersion?: string;
+    currentVersion: string;
+    isPrerelease: boolean;
+}>;
+/**
+ * Performs an update by running the install script.
+ * Used by both CLI and daemon for updates.
+ */
+export declare function performUpdate(options?: {
+    silent?: boolean;
+}): Promise<boolean>;
+/**
+ * Background update check for the daemon.
+ * Checks for updates and triggers install script if available.
+ */
+export declare function daemonUpdateCheck(): Promise<boolean>;
+/**
+ * Checks for updates and performs auto-update if available.
+ * Called when CLI starts.
+ * Returns true if an update was installed and the CLI should exit.
  */
 export declare function attemptUpdate(): Promise<boolean>;

package/dist/utils/websocket.d.ts

@@ -0,0 +1,5 @@
+import WebSocket from 'ws';
+/**
+ * Safely closes a WebSocket without throwing or emitting unhandled errors.
+ */
+export declare function safeCloseWebSocket(ws: WebSocket): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnara",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "type": "module",
   "description": "Command-line interface for Omnara.",
   "main": "dist/cli.js",
@@ -11,6 +11,9 @@
   "scripts": {
     "build": "npm run build:types && node build.mjs && npm run copy-assets",
     "build:types": "tsc --emitDeclarationOnly --project tsconfig.json",
+    "build:exe": "bun run scripts/build-executable.ts",
+    "build:exe:all": "bun run scripts/build-executable.ts --all",
+    "build:release": "bun run scripts/build-executable.ts --all && bun run scripts/generate-release-json.ts",
     "copy-assets": "node scripts/copy-assets.mjs",
     "preinstall": "node scripts/preinstall.js"
   },
@@ -31,7 +34,7 @@
     "@anthropic-ai/claude-agent-sdk": "^0.1.42",
     "@anthropic-ai/sdk": "^0.67.0",
     "@modelcontextprotocol/sdk": "^1.20.1",
-    "@sentry/node": "^10.26.0",
+    "@sentry/node": "^10.28.0",
     "@types/glob": "^8.1.0",
     "ajv": "^8.17.1",
     "ajv-formats": "^2.1.1",

package/scripts/build-executable.ts

@@ -0,0 +1,244 @@
+#!/usr/bin/env bun
+/**
+ * Build script for creating Bun single-file executables.
+ *
+ * This script uses Bun's built-in compile feature to create standalone
+ * executables that include the Bun runtime and all dependencies.
+ *
+ * Usage:
+ *   bun run scripts/build-executable.ts                    # Build for current platform
+ *   bun run scripts/build-executable.ts --all              # Build for all platforms
+ *   bun run scripts/build-executable.ts --target linux-x64 # Build for specific target
+ *
+ * Supported targets:
+ *   - darwin-arm64  (macOS Apple Silicon)
+ *   - darwin-x64    (macOS Intel)
+ *   - linux-x64     (Linux x64)
+ *   - linux-arm64   (Linux ARM64)
+ *   - windows-x64   (Windows x64)
+ */
+
+import { spawn } from 'bun';
+import { existsSync, mkdirSync, statSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { readFileSync } from 'node:fs';
+
+// Get the path to the bun executable (handles cases where bun isn't in PATH)
+const bunPath = process.execPath;
+
+const projectRoot = resolve(dirname(import.meta.path), '..');
+const distDir = join(projectRoot, 'dist');
+const exeDir = join(distDir, 'exe');
+const entryPoint = join(projectRoot, 'src', 'cli.ts');
+
+// Read package.json for version info
+const pkgJson = JSON.parse(
+  readFileSync(join(projectRoot, 'package.json'), 'utf8')
+) as { version?: string; name?: string; description?: string };
+
+const version = pkgJson.version ?? '0.0.0';
+const packageName = pkgJson.name ?? 'omnara';
+const packageDescription = pkgJson.description ?? 'Command-line interface for Omnara.';
+
+// Bun compile targets
+type BunTarget =
+  | 'bun-darwin-arm64'
+  | 'bun-darwin-x64'
+  | 'bun-linux-x64'
+  | 'bun-linux-arm64'
+  | 'bun-linux-x64-baseline'
+  | 'bun-linux-arm64-musl'
+  | 'bun-linux-x64-musl'
+  | 'bun-windows-x64'
+  | 'bun-windows-x64-baseline';
+
+interface TargetConfig {
+  bunTarget: BunTarget;
+  outputName: string;
+  description: string;
+}
+
+const TARGETS: Record<string, TargetConfig> = {
+  'darwin-arm64': {
+    bunTarget: 'bun-darwin-arm64',
+    outputName: 'omnara-darwin-arm64',
+    description: 'macOS Apple Silicon',
+  },
+  'darwin-x64': {
+    bunTarget: 'bun-darwin-x64',
+    outputName: 'omnara-darwin-x64',
+    description: 'macOS Intel',
+  },
+  'linux-x64': {
+    bunTarget: 'bun-linux-x64',
+    outputName: 'omnara-linux-x64',
+    description: 'Linux x64',
+  },
+  'linux-arm64': {
+    bunTarget: 'bun-linux-arm64',
+    outputName: 'omnara-linux-arm64',
+    description: 'Linux ARM64',
+  },
+  'linux-x64-musl': {
+    bunTarget: 'bun-linux-x64-musl',
+    outputName: 'omnara-linux-x64-musl',
+    description: 'Linux x64 (musl/Alpine)',
+  },
+  'windows-x64': {
+    bunTarget: 'bun-windows-x64',
+    outputName: 'omnara-windows-x64.exe',
+    description: 'Windows x64',
+  },
+};
+
+// Map current platform to target name
+function getCurrentPlatformTarget(): string {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === 'darwin' && arch === 'arm64') return 'darwin-arm64';
+  if (platform === 'darwin' && arch === 'x64') return 'darwin-x64';
+  if (platform === 'linux' && arch === 'x64') return 'linux-x64';
+  if (platform === 'linux' && arch === 'arm64') return 'linux-arm64';
+  if (platform === 'win32' && arch === 'x64') return 'windows-x64';
+
+  throw new Error(`Unsupported platform: ${platform}-${arch}`);
+}
+
+async function buildTarget(targetName: string, config: TargetConfig): Promise<boolean> {
+  const outputPath = join(exeDir, config.outputName);
+
+  console.log(`\nBuilding ${config.description} (${targetName})...`);
+  console.log(`  Target: ${config.bunTarget}`);
+  console.log(`  Output: ${outputPath}`);
+  console.log(`  Version: ${version}`);
+
+  const args = [
+    'build',
+    entryPoint,
+    '--compile',
+    '--target', config.bunTarget,
+    '--outfile', outputPath,
+    '--minify',
+    '--sourcemap',
+    // Define package info constants at compile time (values must be JSON strings)
+    '--define', `__PACKAGE_NAME__=${JSON.stringify(packageName)}`,
+    '--define', `__PACKAGE_VERSION__=${JSON.stringify(version)}`,
+    '--define', `__PACKAGE_DESCRIPTION__=${JSON.stringify(packageDescription)}`,
+  ];
+
+  // Debug: print full command
+  console.log(`  Command: ${bunPath} ${args.join(' ')}`);
+
+  const proc = spawn({
+    cmd: [bunPath, ...args],
+    cwd: projectRoot,
+    stdout: 'inherit',
+    stderr: 'inherit',
+  });
+
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    console.error(`  Build failed with exit code ${exitCode}`);
+    return false;
+  }
+
+  // Get file size
+  if (existsSync(outputPath)) {
+    const stats = statSync(outputPath);
+    const sizeMB = (stats.size / (1024 * 1024)).toFixed(2);
+    console.log(`  Size: ${sizeMB} MB`);
+  }
+
+  return true;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  console.log('='.repeat(60));
+  console.log(`Omnara CLI Executable Builder (v${version})`);
+  console.log('='.repeat(60));
+
+  // Create output directory
+  mkdirSync(exeDir, { recursive: true });
+
+  let targets: string[] = [];
+
+  if (args.includes('--all')) {
+    // Build all targets
+    targets = Object.keys(TARGETS);
+    console.log('\nBuilding for all platforms...');
+  } else if (args.includes('--target')) {
+    // Build specific target
+    const targetIndex = args.indexOf('--target');
+    const targetName = args[targetIndex + 1];
+
+    if (!targetName || !TARGETS[targetName]) {
+      console.error(`Invalid target: ${targetName}`);
+      console.error(`Available targets: ${Object.keys(TARGETS).join(', ')}`);
+      process.exit(1);
+    }
+
+    targets = [targetName];
+  } else {
+    // Build for current platform
+    const currentTarget = getCurrentPlatformTarget();
+    targets = [currentTarget];
+    console.log(`\nBuilding for current platform: ${currentTarget}`);
+  }
+
+  const results: { target: string; success: boolean }[] = [];
+
+  for (const targetName of targets) {
+    const config = TARGETS[targetName];
+    if (!config) {
+      console.error(`Unknown target: ${targetName}`);
+      results.push({ target: targetName, success: false });
+      continue;
+    }
+
+    const success = await buildTarget(targetName, config);
+    results.push({ target: targetName, success });
+  }
+
+  // Print summary
+  console.log('\n' + '='.repeat(60));
+  console.log('Build Summary');
+  console.log('='.repeat(60));
+
+  let allSuccess = true;
+  for (const result of results) {
+    const status = result.success ? 'SUCCESS' : 'FAILED';
+    const config = TARGETS[result.target];
+    console.log(`  ${result.target}: ${status}`);
+    if (result.success && config) {
+      console.log(`    -> ${join(exeDir, config.outputName)}`);
+    }
+    if (!result.success) allSuccess = false;
+  }
+
+  console.log('');
+
+  if (!allSuccess) {
+    process.exit(1);
+  }
+
+  // Print usage instructions for single target builds
+  if (targets.length === 1 && results[0]?.success) {
+    const config = TARGETS[targets[0]];
+    if (config) {
+      const binaryPath = join(exeDir, config.outputName);
+      console.log('To test the executable:');
+      console.log(`  ${binaryPath} --help`);
+      console.log(`  ${binaryPath} --version`);
+      console.log('');
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error('Build failed:', error);
+  process.exit(1);
+});

package/scripts/generate-release-json.ts

@@ -0,0 +1,136 @@
+#!/usr/bin/env bun
+/**
+ * Generates release.json manifest for CLI releases.
+ *
+ * This script scans the dist/exe directory for built binaries,
+ * calculates SHA256 checksums, and generates a release.json file
+ * that the auto-update system uses to check for new versions.
+ *
+ * Usage:
+ *   bun run scripts/generate-release-json.ts
+ *   bun run scripts/generate-release-json.ts --version 0.5.0
+ *   bun run scripts/generate-release-json.ts --base-url https://releases.example.com
+ */
+
+import { createHash } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+const projectRoot = resolve(dirname(import.meta.path), '..');
+const exeDir = join(projectRoot, 'dist', 'exe');
+const pkgJsonPath = join(projectRoot, 'package.json');
+
+interface PlatformInfo {
+  url: string;
+  sha256: string;
+}
+
+interface ReleaseInfo {
+  version: string;
+  released_at: string;
+  platforms: Record<string, PlatformInfo>;
+}
+
+function parseArgs(): { version?: string; baseUrl: string } {
+  const args = process.argv.slice(2);
+  let version: string | undefined;
+  let baseUrl = process.env.RELEASE_BASE_URL ?? 'https://releases.omnara.com';
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--version' && args[i + 1]) {
+      version = args[i + 1];
+      i++;
+    } else if (args[i] === '--base-url' && args[i + 1]) {
+      baseUrl = args[i + 1];
+      i++;
+    }
+  }
+
+  return { version, baseUrl };
+}
+
+function getPackageVersion(): string {
+  const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf8')) as { version?: string };
+  return pkgJson.version ?? '0.0.0';
+}
+
+function calculateSha256(filePath: string): string {
+  const content = readFileSync(filePath);
+  return createHash('sha256').update(content).digest('hex');
+}
+
+function extractPlatform(filename: string): string {
+  // omnara-darwin-arm64 -> darwin-arm64
+  // omnara-linux-x64-musl -> linux-x64-musl
+  // omnara-windows-x64.exe -> windows-x64
+  return filename.replace(/^omnara-/, '').replace(/\.exe$/, '');
+}
+
+function main(): void {
+  const { version: argVersion, baseUrl } = parseArgs();
+  const version = argVersion ?? getPackageVersion();
+
+  console.log('='.repeat(60));
+  console.log('Generating release.json');
+  console.log('='.repeat(60));
+  console.log(`  Version:  ${version}`);
+  console.log(`  Base URL: ${baseUrl}`);
+  console.log(`  Exe Dir:  ${exeDir}`);
+  console.log('');
+
+  if (!existsSync(exeDir)) {
+    console.error(`Error: Executable directory not found: ${exeDir}`);
+    console.error('Run "bun run scripts/build-executable.ts --all" first.');
+    process.exit(1);
+  }
+
+  const files = readdirSync(exeDir).filter((f) => {
+    return f.startsWith('omnara-') && !f.endsWith('.sha256') && !f.endsWith('.json');
+  });
+
+  if (files.length === 0) {
+    console.error('Error: No executable files found in dist/exe/');
+    console.error('Run "bun run scripts/build-executable.ts --all" first.');
+    process.exit(1);
+  }
+
+  console.log('Found executables:');
+  const platforms: Record<string, PlatformInfo> = {};
+
+  for (const file of files) {
+    const filePath = join(exeDir, file);
+    const platform = extractPlatform(file);
+    const sha256 = calculateSha256(filePath);
+
+    platforms[platform] = {
+      url: `${baseUrl}/${version}/${file}`,
+      sha256,
+    };
+
+    // Also write individual .sha256 file
+    const sha256Path = `${filePath}.sha256`;
+    writeFileSync(sha256Path, sha256);
+
+    console.log(`  ${platform}:`);
+    console.log(`    File:   ${file}`);
+    console.log(`    SHA256: ${sha256}`);
+    console.log(`    URL:    ${platforms[platform].url}`);
+  }
+
+  const release: ReleaseInfo = {
+    version,
+    released_at: new Date().toISOString(),
+    platforms,
+  };
+
+  const releasePath = join(exeDir, 'release.json');
+  writeFileSync(releasePath, JSON.stringify(release, null, 2) + '\n');
+
+  console.log('');
+  console.log(`Generated: ${releasePath}`);
+  console.log('');
+  console.log('Release manifest:');
+  console.log(JSON.stringify(release, null, 2));
+}
+
+main();