omnara 0.1.5 → 0.1.6

package/dist/cli.js

@@ -5,8 +5,8 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 // src/cli.ts
-import path3 from "path";
-import { createRequire } from "node:module";
+import path4 from "path";
+import { createRequire as createRequire2 } from "node:module";
 import { Command as Command3 } from "commander";
 
 // src/commands/agent.ts
@@ -17,7 +17,9 @@ import { randomUUID as randomUUID3 } from "crypto";
 
 // src/orchestrator/ai-client.ts
 import fs from "fs";
-import { query } from "@anthropic-ai/claude-agent-sdk";
+import {
+  query
+} from "@anthropic-ai/claude-agent-sdk";
 var BASE_ALLOWED_ORCHESTRATOR_TOOLS = [
   "Glob",
   "Grep",
@@ -52,7 +54,7 @@ var AIClient = class {
   constructor(config) {
     const defaultOptions = {
       maxTurns: 100,
-      model: "opus",
+      model: "sonnet",
       cwd: process.cwd(),
       includePartialMessages: false,
       allowedTools: [...BASE_ALLOWED_ORCHESTRATOR_TOOLS]
@@ -740,7 +742,47 @@ var WorkerManager = class extends EventEmitter {
       record.sessionId,
       record.messageQueue
     );
-    const query2 = client.createQuery(messageStream);
+    const query2 = client.createQuery(messageStream, {
+      hooks: {
+        "PostToolUse": [
+          {
+            // No matcher means it applies to all tools (Bash, Read, Write, etc.)
+            // If we wanted to only capture Bash results, we could add: matcher: 'Bash'
+            hooks: [
+              async (input2, toolUseID, options) => {
+                if (input2.hook_event_name !== "PostToolUse") {
+                  return {};
+                }
+                const postToolInput = input2;
+                console.log("[WorkerManager] PostToolUse hook triggered:", {
+                  toolName: postToolInput.tool_name,
+                  toolUseID,
+                  hasResponse: !!postToolInput.tool_response,
+                  workerId: record.id,
+                  task: record.task
+                });
+                if (postToolInput.tool_name === "Bash") {
+                  console.log("[WorkerManager] Bash tool response structure:", {
+                    responseType: typeof postToolInput.tool_response,
+                    responseKeys: postToolInput.tool_response ? Object.keys(postToolInput.tool_response) : [],
+                    fullResponse: postToolInput.tool_response
+                  });
+                }
+                this.emit("message", {
+                  record,
+                  messageType: "tool_result",
+                  toolUseId: toolUseID || randomUUID2(),
+                  toolContent: postToolInput.tool_response,
+                  isError: false
+                  // PostToolUse is for successful executions
+                });
+                return {};
+              }
+            ]
+          }
+        ]
+      }
+    });
     this.runningQueries.set(record.id, query2);
     const summarizedChunks = [];
     try {
@@ -1530,7 +1572,8 @@ var AgentOrchestrator = class {
           toolName: event.toolName,
           workerId: event.record.id,
           task: event.record.task,
-          targetSessionId
+          targetSessionId,
+          toolUseId: event.toolUseId
         });
         this.broadcastToAll({
           type: "tool_call",
@@ -1547,6 +1590,13 @@ var AgentOrchestrator = class {
         if (!event.toolUseId) {
           return;
         }
+        console.log("[Orchestrator] Broadcasting worker tool_result:", {
+          toolName: event.toolName,
+          workerId: event.record.id,
+          task: event.record.task,
+          targetSessionId,
+          toolUseId: event.toolUseId
+        });
         this.broadcastToAll({
           type: "tool_result",
           sessionId: targetSessionId,
@@ -1784,8 +1834,8 @@ var ApiClient = class {
   constructor(options) {
     this.baseUrl = normalizeBaseUrl(options.baseUrl);
   }
-  async getJson(path4, options) {
-    const url = resolveUrl(this.baseUrl, path4);
+  async getJson(path5, options) {
+    const url = resolveUrl(this.baseUrl, path5);
     const headers = this.buildHeaders(options);
     const response = await fetch(url, {
       method: "GET",
@@ -1794,8 +1844,8 @@ var ApiClient = class {
     });
     return await this.handleResponse(response);
   }
-  async postJson(path4, body, options) {
-    const url = resolveUrl(this.baseUrl, path4);
+  async postJson(path5, body, options) {
+    const url = resolveUrl(this.baseUrl, path5);
     const headers = this.buildHeaders(options, { includeJson: true });
     const response = await fetch(url, {
       method: "POST",
@@ -1853,12 +1903,12 @@ function normalizeBaseUrl(raw) {
   }
   return raw.endsWith("/") ? raw : `${raw}/`;
 }
-function resolveUrl(base, path4) {
+function resolveUrl(base, path5) {
   const baseUrl = new URL(base);
-  if (!path4.startsWith("/")) {
-    path4 = `/${path4}`;
+  if (!path5.startsWith("/")) {
+    path5 = `/${path5}`;
   }
-  const resolved = new URL(path4, baseUrl);
+  const resolved = new URL(path5, baseUrl);
   return resolved.toString();
 }
 function extractDetail(payload) {
@@ -2011,9 +2061,6 @@ function deriveAccessExpiry(session) {
   return void 0;
 }
 
-// src/auth/login-flow.ts
-import { spawn } from "child_process";
-
 // src/utils/prompt.ts
 import readline from "readline/promises";
 import { stdin as input, stdout as output } from "process";
@@ -2185,7 +2232,7 @@ var LoopbackListener = class _LoopbackListener {
   }
 };
 function buildSuccessHtml() {
-  const redirectTarget = "https://voice.omnara.com/dashboard";
+  const redirectTarget = "https://www.omnara.com/dashboard";
   return `<!doctype html>
 <html lang="en">
   <head>
@@ -2240,6 +2287,18 @@ function buildMessageHtml(message) {
 </html>`;
 }
 
+// src/utils/browser.ts
+import { spawn } from "child_process";
+function tryOpenBrowser(url) {
+  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+  try {
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    child.unref();
+  } catch {
+  }
+}
+
 // src/auth/login-flow.ts
 async function performVerificationLogin({
   backendUrlOption,
@@ -2339,8 +2398,8 @@ async function performVerificationLogin({
   }
   return latestCredentials;
 }
-var DEFAULT_BACKEND_URL = "https://omnara-voice.onrender.com/";
-var DEFAULT_FRONTEND_URL = "https://voice.omnara.com/";
+var DEFAULT_BACKEND_URL = "https://api.omnara.com/";
+var DEFAULT_FRONTEND_URL = "https://www.omnara.com/";
 function resolveBackendUrl(option) {
   const candidate = option ?? process.env.OMNARA_BACKEND_URL ?? DEFAULT_BACKEND_URL;
   return normalizeBaseUrl(candidate);
@@ -2393,15 +2452,6 @@ function printSessionInstructions(session) {
   console.log(`  ${session.verificationUriComplete}`);
   console.log("Approve the request, then return to the CLI.");
 }
-function tryOpenBrowser(url) {
-  const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
-  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  try {
-    const child = spawn(command, args, { stdio: "ignore", detached: true });
-    child.unref();
-  } catch {
-  }
-}
 function extractErrorMessage4(error) {
   if (error instanceof Error && error.message) {
     return error.message;
@@ -4736,6 +4786,7 @@ var RelayBridge = class extends EventEmitter2 {
   authProviderPromise = null;
   userSessionId = null;
   currentAgentSessionId = null;
+  browserOpened = false;
   constructor(orchestrator, options) {
     super();
     this.orchestrator = orchestrator;
@@ -4779,6 +4830,7 @@ var RelayBridge = class extends EventEmitter2 {
   async stop() {
     this.stopped = true;
     this.currentAgentSessionId = null;
+    this.browserOpened = false;
     if (this.pingTimer) {
       clearInterval(this.pingTimer);
       this.pingTimer = null;
@@ -4818,6 +4870,13 @@ var RelayBridge = class extends EventEmitter2 {
     this.heartbeatIntervalMs = registration.relayHeartbeatIntervalSec * 1e3;
     this.startPingTimer();
     await this.sendPrimarySessionInit(ws);
+    if (this.frontendUrl && !this.browserOpened) {
+      const dashboardUrl = new URL("dashboard", this.frontendUrl);
+      dashboardUrl.searchParams.set("session", agentSessionId);
+      tryOpenBrowser(dashboardUrl.toString());
+      this.logger.log(`Opened dashboard at ${dashboardUrl.toString()}`);
+      this.browserOpened = true;
+    }
     this.flushQueue();
     await this.handleWebsocketLifecycle(ws);
   }
@@ -4836,7 +4895,7 @@ var RelayBridge = class extends EventEmitter2 {
     if (!this.currentAgentSessionId) {
       this.currentAgentSessionId = randomUUID4();
     }
-    const session = this.orchestrator.ensureSessionExists(this.currentAgentSessionId);
+    this.orchestrator.ensureSessionExists(this.currentAgentSessionId);
     this.orchestrator.setMainCodingSessionId(this.currentAgentSessionId);
     return this.currentAgentSessionId;
   }
@@ -5316,16 +5375,16 @@ var RelayBridge = class extends EventEmitter2 {
     }
   }
 };
-function buildRelayWebsocketUrl(baseUrl, path4) {
+function buildRelayWebsocketUrl(baseUrl, path5) {
   const url = new URL(baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   url.search = "";
   url.hash = "";
-  if (path4.startsWith("/")) {
-    url.pathname = path4;
+  if (path5.startsWith("/")) {
+    url.pathname = path5;
   } else {
     const basePath = url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`;
-    url.pathname = `${basePath}${path4}`;
+    url.pathname = `${basePath}${path5}`;
   }
   return url.toString();
 }
@@ -5666,7 +5725,7 @@ Commands:
 
 // src/voice/voice-service.ts
 async function launchVoiceForSession(client, accessToken, options) {
-  const path4 = `/api/v1/voice/sessions/${options.sessionId}/launch`;
+  const path5 = `/api/v1/voice/sessions/${options.sessionId}/launch`;
   const requestBody = {};
   if (options.force) {
     requestBody.force = true;
@@ -5675,7 +5734,7 @@ async function launchVoiceForSession(client, accessToken, options) {
     requestBody.room_name = options.roomName;
   }
   const response = await client.postJson(
-    path4,
+    path5,
     requestBody,
     { accessToken }
   );
@@ -5693,6 +5752,287 @@ async function launchVoiceForSession(client, accessToken, options) {
   };
 }
 
+// src/utils/claude-code-check.ts
+import { execSync } from "child_process";
+import chalk from "chalk";
+function checkClaudeCodeInstallation() {
+  try {
+    execSync("claude --version", {
+      stdio: "ignore",
+      encoding: "utf-8"
+    });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+function displayClaudeCodeWarning() {
+  console.log(chalk.yellow("\nWarning: Claude Code is not installed or not found in PATH"));
+  console.log(chalk.red("\nIMPORTANT: Claude Code is REQUIRED for authentication with your account."));
+  console.log(chalk.white("\nClaude Code provides:"));
+  console.log(chalk.gray("  - AI-powered code assistance"));
+  console.log(chalk.gray("  - Intelligent code completion"));
+  console.log(chalk.gray("  - Natural language to code translation"));
+  console.log(chalk.gray("  - User authentication for API access"));
+  console.log(chalk.white("\nTo install Claude Code:"));
+  console.log(chalk.cyan("  1. Visit: https://claude.ai/download"));
+  console.log(chalk.cyan("  2. Download and install Claude Code for your platform"));
+  console.log(chalk.cyan('  3. Make sure the "claude" command is available in your PATH'));
+  console.log(chalk.yellow("\nNote: Without Claude Code, you cannot authenticate and access"));
+  console.log(chalk.yellow("personalized features that require your user credentials.\n"));
+}
+function performClaudeCodeCheck(options = {}) {
+  const { silent = false, exitOnMissing = false } = options;
+  if (process.env.OMNARA_SKIP_CLAUDE_CHECK === "true") {
+    return true;
+  }
+  const isInstalled = checkClaudeCodeInstallation();
+  if (!isInstalled && !silent) {
+    displayClaudeCodeWarning();
+    if (exitOnMissing) {
+      console.error(chalk.red("Exiting: Claude Code is required for this operation."));
+      process.exit(1);
+    }
+  }
+  return isInstalled;
+}
+function getClaudeCodeVersion() {
+  try {
+    const version = execSync("claude --version", {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return version;
+  } catch (error) {
+    return null;
+  }
+}
+
+// src/utils/logger.ts
+import path3 from "path";
+function isProduction() {
+  if (process.env.NODE_ENV === "production") {
+    return true;
+  }
+  try {
+    const currentFile = typeof __filename !== "undefined" ? __filename : "";
+    const isInDist = currentFile.includes(path3.sep + "dist" + path3.sep);
+    if (isInDist && process.env.NODE_ENV !== "development") {
+      return true;
+    }
+  } catch {
+  }
+  const logLevel = process.env.OMNARA_LOG_LEVEL?.toLowerCase();
+  if (logLevel === "none" || logLevel === "silent") {
+    return true;
+  }
+  return false;
+}
+function getLogLevel() {
+  const envLevel = process.env.OMNARA_LOG_LEVEL?.toLowerCase();
+  switch (envLevel) {
+    case "none":
+    case "silent":
+      return 0 /* NONE */;
+    case "error":
+      return 1 /* ERROR */;
+    case "warn":
+    case "warning":
+      return 2 /* WARN */;
+    case "info":
+      return 3 /* INFO */;
+    case "debug":
+      return 4 /* DEBUG */;
+    case "verbose":
+    case "trace":
+      return 5 /* VERBOSE */;
+    default:
+      return isProduction() ? 1 /* ERROR */ : 3 /* INFO */;
+  }
+}
+var ControlledLogger = class {
+  logLevel;
+  forceOutput;
+  _console;
+  // Console properties we need to implement
+  Console;
+  constructor(options) {
+    this.logLevel = options?.logLevel ?? getLogLevel();
+    this.forceOutput = options?.forceOutput ?? false;
+    this._console = console;
+    this.Console = console.Console;
+  }
+  /**
+   * Standard log output (INFO level)
+   */
+  log(...args) {
+    if (this.shouldLog(3 /* INFO */)) {
+      console.log(...args);
+    }
+  }
+  /**
+   * Error output (always shown unless NONE)
+   */
+  error(...args) {
+    if (this.shouldLog(1 /* ERROR */)) {
+      console.error(...args);
+    }
+  }
+  /**
+   * Warning output
+   */
+  warn(...args) {
+    if (this.shouldLog(2 /* WARN */)) {
+      console.warn(...args);
+    }
+  }
+  /**
+   * Info level output
+   */
+  info(...args) {
+    if (this.shouldLog(3 /* INFO */)) {
+      console.info(...args);
+    }
+  }
+  /**
+   * Debug output (only in development)
+   */
+  debug(...args) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      console.debug(...args);
+    }
+  }
+  /**
+   * Verbose/trace output
+   */
+  trace(...args) {
+    if (this.shouldLog(5 /* VERBOSE */)) {
+      console.log("[TRACE]", ...args);
+    }
+  }
+  /**
+   * Important messages that should always be shown to user
+   * (authentication status, connection info, etc.)
+   */
+  important(...args) {
+    if (this.logLevel !== 0 /* NONE */ || this.forceOutput) {
+      console.log(...args);
+    }
+  }
+  /**
+   * Success messages that should typically be shown
+   */
+  success(...args) {
+    if (this.shouldLog(2 /* WARN */) || this.forceOutput) {
+      console.log(...args);
+    }
+  }
+  /**
+   * Check if a message should be logged at the given level
+   */
+  shouldLog(level) {
+    return this.forceOutput || this.logLevel >= level;
+  }
+  /**
+   * Update the log level dynamically
+   */
+  setLogLevel(level) {
+    this.logLevel = level;
+  }
+  /**
+   * Get current log level
+   */
+  getLogLevel() {
+    return this.logLevel;
+  }
+  // Console methods we delegate or control based on log level
+  assert(condition, ...data) {
+    if (this.shouldLog(1 /* ERROR */)) {
+      this._console.assert(condition, ...data);
+    }
+  }
+  clear() {
+    this._console.clear();
+  }
+  count(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.count(label);
+    }
+  }
+  countReset(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.countReset(label);
+    }
+  }
+  dir(item, options) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.dir(item, options);
+    }
+  }
+  dirxml(...data) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.dirxml(...data);
+    }
+  }
+  group(...data) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.group(...data);
+    }
+  }
+  groupCollapsed(...data) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.groupCollapsed(...data);
+    }
+  }
+  groupEnd() {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.groupEnd();
+    }
+  }
+  table(tabularData, properties) {
+    if (this.shouldLog(3 /* INFO */)) {
+      this._console.table(tabularData, properties);
+    }
+  }
+  time(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.time(label);
+    }
+  }
+  timeEnd(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.timeEnd(label);
+    }
+  }
+  timeLog(label, ...data) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.timeLog(label, ...data);
+    }
+  }
+  timeStamp(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.timeStamp(label);
+    }
+  }
+  profile(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.profile?.(label);
+    }
+  }
+  profileEnd(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      this._console.profileEnd?.(label);
+    }
+  }
+};
+var logger = new ControlledLogger();
+function extractErrorMessage6(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
 // src/commands/agent.ts
 function buildAgentCommand() {
   const agent = new Command("agent").description(
@@ -5710,6 +6050,12 @@ function buildAgentCommand() {
   return agent;
 }
 async function runAgentOrchestrator(options = {}) {
+  const claudeVersion = getClaudeCodeVersion();
+  if (claudeVersion) {
+    logger.info(`\u2713 Claude Code detected: ${claudeVersion}`);
+  } else {
+    logger.info("\u2139 Running without Claude Code integration");
+  }
   const orchestrator = new AgentOrchestrator();
   await orchestrator.start();
   const backendUrl = resolveBackendUrl(options.backendUrl);
@@ -5731,7 +6077,7 @@ async function runAgentOrchestrator(options = {}) {
   try {
     await bridge.start();
   } catch (error) {
-    console.error(`Relay orchestrator terminated: ${extractErrorMessage6(error)}`);
+    logger.error(`Relay orchestrator terminated: ${extractErrorMessage6(error)}`);
     process.exitCode = process.exitCode || 1;
   } finally {
     await stop();
@@ -5745,10 +6091,10 @@ function createSignalHandler(onStop) {
       return;
     }
     stopping = true;
-    console.log(`
+    logger.important(`
 Received ${signal}. Shutting down agent orchestrator...`);
     void onStop().catch((error) => {
-      console.error("Error while shutting down agent orchestrator:", error);
+      logger.error("Error while shutting down agent orchestrator:", error);
     });
   };
   const remove = () => {
@@ -5757,12 +6103,6 @@ Received ${signal}. Shutting down agent orchestrator...`);
   };
   return { handler, remove };
 }
-function extractErrorMessage6(error) {
-  if (error instanceof Error) {
-    return error.message;
-  }
-  return String(error);
-}
 async function runRepl(options) {
   const backendUrl = resolveBackendUrl(options.backendUrl);
   const frontendUrl = resolveFrontendUrl(options.frontendUrl);
@@ -5780,7 +6120,7 @@ async function runRepl(options) {
     clientKind: "cli"
   });
   const wsUrl = buildRelayWebsocketUrl2(backendUrl, registration.relayWsPath);
-  console.log(
+  logger.important(
     `Using agent session ${options.sessionId} (user session ${registration.userSessionId})`
   );
   await runTerminalRepl({
@@ -5808,30 +6148,30 @@ async function runVoice(options) {
     force: options.force ?? false,
     roomName: options.roomName
   });
-  console.log("\nVoice agent dispatched successfully.");
-  console.log(`Session ID: ${launch.sessionId}`);
-  console.log(`LiveKit URL: ${launch.livekitUrl}`);
-  console.log(`Room name: ${launch.roomName}`);
-  console.log(`Participant identity: ${launch.accessTokenIdentity}`);
-  console.log("\nUse this token to join the room:");
-  console.log(launch.accessToken);
-  console.log("\nOnce connected (for example via the LiveKit Agents playground),");
-  console.log("the voice worker will coordinate with the CLI coding agent through the relay.");
-  console.log(`Relay websocket: ${launch.relayWsUrl}`);
-  console.log(`Relay token (expires in ${launch.relayTokenExpiresIn}s):`);
-  console.log(launch.relayToken);
-  console.log("\nKeep this information secure\u2014tokens grant access to your agent session.");
+  logger.success("\nVoice agent dispatched successfully.");
+  logger.important(`Session ID: ${launch.sessionId}`);
+  logger.important(`LiveKit URL: ${launch.livekitUrl}`);
+  logger.important(`Room name: ${launch.roomName}`);
+  logger.important(`Participant identity: ${launch.accessTokenIdentity}`);
+  logger.important("\nUse this token to join the room:");
+  logger.important(launch.accessToken);
+  logger.log("\nOnce connected (for example via the LiveKit Agents playground),");
+  logger.log("the voice worker will coordinate with the CLI coding agent through the relay.");
+  logger.debug(`Relay websocket: ${launch.relayWsUrl}`);
+  logger.debug(`Relay token (expires in ${launch.relayTokenExpiresIn}s):`);
+  logger.debug(launch.relayToken);
+  logger.important("\nKeep this information secure\u2014tokens grant access to your agent session.");
 }
-function buildRelayWebsocketUrl2(baseUrl, path4) {
+function buildRelayWebsocketUrl2(baseUrl, path5) {
   const url = new URL(baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   url.search = "";
   url.hash = "";
-  if (path4.startsWith("/")) {
-    url.pathname = path4;
+  if (path5.startsWith("/")) {
+    url.pathname = path5;
   } else {
     const basePath = url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`;
-    url.pathname = `${basePath}${path4}`;
+    url.pathname = `${basePath}${path5}`;
   }
   return url.toString();
 }
@@ -5907,9 +6247,79 @@ function extractErrorMessage7(error) {
   return String(error);
 }
 
-// src/cli.ts
+// src/utils/version-check.ts
+import https from "https";
+import { createRequire } from "node:module";
 var require2 = createRequire(import.meta.url);
-var packageJson = require2("../package.json");
+async function fetchLatestVersion(packageName) {
+  return new Promise((resolve) => {
+    const url = `https://registry.npmjs.org/${packageName}`;
+    https.get(url, { timeout: 3e3 }, (res) => {
+      let data = "";
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        try {
+          if (res.statusCode !== 200) {
+            resolve(null);
+            return;
+          }
+          const packageInfo = JSON.parse(data);
+          resolve(packageInfo["dist-tags"]?.latest || null);
+        } catch {
+          resolve(null);
+        }
+      });
+    }).on("error", () => {
+      resolve(null);
+    }).on("timeout", () => {
+      resolve(null);
+    });
+  });
+}
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const part1 = parts1[i] || 0;
+    const part2 = parts2[i] || 0;
+    if (part1 > part2) return 1;
+    if (part1 < part2) return -1;
+  }
+  return 0;
+}
+async function checkForUpdates() {
+  try {
+    const packageJson2 = require2("../../package.json");
+    const currentVersion = packageJson2.version;
+    const packageName = packageJson2.name;
+    if (!currentVersion || !packageName) {
+      return;
+    }
+    const latestVersion = await fetchLatestVersion(packageName);
+    if (!latestVersion) {
+      return;
+    }
+    if (compareVersions(latestVersion, currentVersion) > 0) {
+      console.log("\n" + "\u2550".repeat(60));
+      console.log("Update available!");
+      console.log(`Current version: ${currentVersion}`);
+      console.log(`Latest version: ${latestVersion}`);
+      console.log(`Run \`npm install -g ${packageName}@latest\` to update`);
+      console.log("\u2550".repeat(60) + "\n");
+    }
+  } catch {
+  }
+}
+function checkForUpdatesInBackground() {
+  checkForUpdates().catch(() => {
+  });
+}
+
+// src/cli.ts
+var require3 = createRequire2(import.meta.url);
+var packageJson = require3("../package.json");
 function createProgram() {
   const program = new Command3();
   program.name("omnara").description(packageJson.description ?? "Command-line interface for Omnara.").version(packageJson.version ?? "0.0.0").option("--backend-url <url>", "Override backend API base URL used for login").option("--frontend-url <url>", "Override frontend URL opened during login").action(async () => {
@@ -5922,6 +6332,8 @@ function createProgram() {
 }
 async function run(argv) {
   const program = createProgram();
+  performClaudeCodeCheck({ silent: false, exitOnMissing: false });
+  checkForUpdatesInBackground();
   try {
     await program.parseAsync(argv);
   } catch (error) {
@@ -5932,13 +6344,13 @@ function isMainModule() {
   if (!import.meta.url || !process.argv[1]) {
     return false;
   }
-  const executedPath = path3.resolve(process.argv[1]);
+  const executedPath = path4.resolve(process.argv[1]);
   const currentPath = import.meta.url.startsWith("file://") ? decodeURIComponent(import.meta.url.slice(7)) : import.meta.url;
-  return path3.normalize(currentPath) === path3.normalize(executedPath);
+  return path4.normalize(currentPath) === path4.normalize(executedPath);
 }
 if (isMainModule()) {
   run(process.argv).catch((error) => {
-    console.error(error);
+    logger.error(error);
     process.exitCode = 1;
   });
 }