omnara 0.1.8 → 0.1.10

package/dist/cli.js

@@ -5,7 +5,7 @@ const __filename = __omnaraFileURLToPath(import.meta.url);
 const __dirname = pathShim.dirname(__filename);
 
 // src/cli.ts
-import path4 from "path";
+import path6 from "path";
 import { createRequire as createRequire2 } from "node:module";
 import { Command as Command3 } from "commander";
 
@@ -63,6 +63,9 @@ var AIClient = class {
       ...defaultOptions,
       ...config?.defaults
     };
+    if (this.baseOptions.cwd && this.baseOptions.cwd !== process.cwd()) {
+      console.log("[AIClient] Using custom working directory:", this.baseOptions.cwd);
+    }
     this.ensureWorkingDirectory(this.baseOptions.cwd);
   }
   async *streamUserMessage(prompt2, overrides) {
@@ -540,14 +543,644 @@ var AsyncQueue = class {
   }
 };
 
+// src/orchestrator/utils/worktree-manager.ts
+import { simpleGit } from "simple-git";
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+
+// src/utils/logger.ts
+import path2 from "path";
+function isProduction() {
+  if (process.env.NODE_ENV === "production") {
+    return true;
+  }
+  try {
+    const currentFile = typeof __filename !== "undefined" ? __filename : "";
+    const isInDist = currentFile.includes(path2.sep + "dist" + path2.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 */)) {
+      const consoleWithProfile = this._console;
+      consoleWithProfile.profile?.(label);
+    }
+  }
+  profileEnd(label) {
+    if (this.shouldLog(4 /* DEBUG */)) {
+      const consoleWithProfileEnd = this._console;
+      consoleWithProfileEnd.profileEnd?.(label);
+    }
+  }
+};
+var logger = new ControlledLogger();
+function extractErrorMessage2(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/auth/credentials-store.ts
+import fs3 from "fs/promises";
+import os2 from "os";
+import path3 from "path";
+var DEFAULT_DIR = path3.join(os2.homedir(), ".omnara");
+var DEFAULT_CREDENTIALS_PATH = path3.join(DEFAULT_DIR, "creds.json");
+var DEFAULT_FILE_MODE = 384;
+var DEFAULT_DIR_MODE = 448;
+function isStoredCredentials(value) {
+  return Boolean(value) && typeof value === "object";
+}
+var CredentialsStore = class {
+  constructor(filePath = DEFAULT_CREDENTIALS_PATH) {
+    this.filePath = filePath;
+  }
+  async load() {
+    try {
+      const raw = await fs3.readFile(this.filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (!isStoredCredentials(parsed)) {
+        throw new Error("File does not contain valid credentials data");
+      }
+      return parsed;
+    } catch (error) {
+      if (isFileNotFound(error)) {
+        return null;
+      }
+      throw new Error(
+        `Failed to read credentials from ${this.filePath}: ${extractErrorMessage3(error)}`
+      );
+    }
+  }
+  async save(credentials) {
+    const payload = {
+      accessToken: credentials.accessToken,
+      accessTokenExpiresAt: credentials.accessTokenExpiresAt,
+      refreshToken: credentials.refreshToken,
+      refreshTokenExpiresAt: credentials.refreshTokenExpiresAt
+    };
+    await fs3.mkdir(path3.dirname(this.filePath), { recursive: true, mode: DEFAULT_DIR_MODE });
+    const tempPath = `${this.filePath}.tmp`;
+    const serialized = JSON.stringify(payload, null, 2);
+    await fs3.writeFile(tempPath, serialized, { mode: DEFAULT_FILE_MODE });
+    await fs3.chmod(tempPath, DEFAULT_FILE_MODE);
+    await fs3.rename(tempPath, this.filePath);
+  }
+  async clear() {
+    try {
+      await fs3.unlink(this.filePath);
+    } catch (error) {
+      if (!isFileNotFound(error)) {
+        throw new Error(
+          `Failed to remove credentials file ${this.filePath}: ${extractErrorMessage3(error)}`
+        );
+      }
+    }
+  }
+};
+function isFileNotFound(error) {
+  return Boolean(
+    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
+  );
+}
+function extractErrorMessage3(error) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/orchestrator/utils/worktree-manager.ts
+var WorktreeError = class extends Error {
+  constructor(message, workerId, operation, cause) {
+    super(message);
+    this.workerId = workerId;
+    this.operation = operation;
+    this.cause = cause;
+    this.name = "WorktreeError";
+  }
+};
+var WorktreeManager = class {
+  git;
+  repoPath;
+  worktreeBasePath;
+  activeWorktrees;
+  enabled;
+  constructor(options) {
+    this.repoPath = options.repoPath;
+    this.enabled = options.enabled ?? false;
+    const repoName = path4.basename(this.repoPath);
+    this.worktreeBasePath = options.worktreeBasePath || path4.join(DEFAULT_DIR, "worktrees", repoName);
+    this.git = simpleGit(this.repoPath);
+    this.activeWorktrees = /* @__PURE__ */ new Map();
+    if (this.enabled) {
+      this.validateGitRepository();
+    }
+  }
+  /**
+   * Validate that the repoPath is a git repository
+   * Logs an error if worktrees are enabled but not in a git repository
+   */
+  validateGitRepository() {
+    this.git.checkIsRepo().then((isRepo) => {
+      if (!isRepo) {
+        logger.error(`Worktrees are enabled but not in a git repository at ${this.repoPath}`);
+      } else {
+        logger.info(`Worktrees enabled for repository at ${this.repoPath}`);
+      }
+    }).catch((error) => {
+      logger.error(
+        `Worktrees are enabled but failed to check git repository at ${this.repoPath}:`,
+        error
+      );
+    });
+  }
+  /**
+   * Check if worktrees are enabled
+   */
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Creates a new worktree for the specified worker
+   *
+   * @param workerId - Unique identifier for the worker
+   * @param worktreeName - Semantic name for the worktree (e.g., "main-feature", "bugfix-auth")
+   * @returns Information about the created worktree
+   * @throws {WorktreeError} If worktree creation fails
+   */
+  async createWorktree(workerId, worktreeName) {
+    if (!this.enabled) {
+      throw new WorktreeError(
+        'Worktrees are not enabled. Add a "worktrees" configuration to omnara.jsonc to enable.',
+        workerId,
+        "create"
+      );
+    }
+    logger.info(`Creating worktree "${worktreeName}" for worker ${workerId}`);
+    try {
+      if (this.activeWorktrees.has(workerId)) {
+        throw new WorktreeError(
+          `Worktree already exists for worker ${workerId}`,
+          workerId,
+          "create"
+        );
+      }
+      await fs4.mkdir(this.worktreeBasePath, { recursive: true });
+      const branchName = `${worktreeName}`;
+      const worktreePath = path4.join(this.worktreeBasePath, worktreeName);
+      const branches = await this.git.branchLocal();
+      const branchExists = branches.all.includes(branchName);
+      let worktreeDirExists = false;
+      try {
+        await fs4.access(worktreePath);
+        worktreeDirExists = true;
+      } catch {
+        worktreeDirExists = false;
+      }
+      const worktreeList = await this.git.raw(["worktree", "list", "--porcelain"]);
+      const gitWorktrees = this.parseWorktreeList(worktreeList);
+      const worktreeRegistered = gitWorktrees.includes(worktreePath);
+      if (worktreeRegistered && branchExists) {
+        logger.info(
+          `Reusing existing worktree "${worktreeName}" at ${worktreePath} on branch ${branchName}`
+        );
+        const info2 = {
+          workerId,
+          worktreeName,
+          worktreePath,
+          branchName,
+          createdAt: /* @__PURE__ */ new Date()
+        };
+        this.activeWorktrees.set(workerId, info2);
+        return info2;
+      }
+      if (worktreeDirExists && !worktreeRegistered) {
+        logger.warn(
+          `Directory exists at ${worktreePath} but is not a registered worktree. Removing...`
+        );
+        await fs4.rm(worktreePath, { recursive: true, force: true });
+        worktreeDirExists = false;
+      }
+      if (branchExists && !worktreeRegistered) {
+        logger.info(
+          `Branch ${branchName} exists. Creating worktree at ${worktreePath} using existing branch`
+        );
+        await this.git.raw(["worktree", "add", worktreePath, branchName]);
+      } else if (!branchExists && !worktreeRegistered) {
+        logger.info(
+          `Creating new worktree "${worktreeName}" at ${worktreePath} with new branch ${branchName}`
+        );
+        await this.git.raw(["worktree", "add", "-b", branchName, worktreePath]);
+      }
+      const info = {
+        workerId,
+        worktreeName,
+        worktreePath,
+        branchName,
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      this.activeWorktrees.set(workerId, info);
+      logger.info(`Worktree "${worktreeName}" ready at ${worktreePath} on branch ${branchName}`);
+      return info;
+    } catch (error) {
+      logger.error(`Failed to create worktree for worker ${workerId}:`, error);
+      throw new WorktreeError(
+        `Failed to create worktree: ${error instanceof Error ? error.message : String(error)}`,
+        workerId,
+        "create",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Removes a worktree for the specified worker
+   *
+   * @param workerId - Unique identifier for the worker
+   * @param force - Force removal even if there are uncommitted changes
+   * @throws {WorktreeError} If worktree removal fails
+   */
+  async removeWorktree(workerId, force = false) {
+    if (!this.enabled) {
+      return;
+    }
+    logger.info(`Removing worktree for worker ${workerId}`);
+    const info = this.activeWorktrees.get(workerId);
+    if (!info) {
+      logger.warn(`No active worktree found for worker ${workerId}`);
+      return;
+    }
+    try {
+      const args = ["worktree", "remove", info.worktreePath];
+      if (force) {
+        args.push("--force");
+      }
+      try {
+        await this.git.raw(args);
+      } catch (worktreeError) {
+        const errorMessage = worktreeError instanceof Error ? worktreeError.message : String(worktreeError);
+        if (errorMessage.includes("is not a working tree") || errorMessage.includes("does not exist")) {
+          logger.warn(
+            `Worktree ${info.worktreePath} doesn't exist, may have been manually removed. Cleaning up...`
+          );
+          await this.git.raw(["worktree", "prune"]);
+          try {
+            await fs4.rm(info.worktreePath, { recursive: true, force: true });
+            logger.info(`Manually removed stale worktree directory: ${info.worktreePath}`);
+          } catch {
+          }
+        } else {
+          throw worktreeError;
+        }
+      }
+      this.activeWorktrees.delete(workerId);
+      logger.info(`Removed worktree for worker ${workerId}`);
+    } catch (error) {
+      logger.error(`Failed to remove worktree for worker ${workerId}:`, error);
+      throw new WorktreeError(
+        `Failed to remove worktree: ${error instanceof Error ? error.message : String(error)}`,
+        workerId,
+        "remove",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Gets information about a worker's worktree
+   *
+   * @param workerId - Unique identifier for the worker
+   * @returns Worktree information or undefined if not found
+   */
+  getWorktreeInfo(workerId) {
+    return this.activeWorktrees.get(workerId);
+  }
+  /**
+   * Lists all active worktrees managed by this instance
+   *
+   * @returns Array of worktree information
+   */
+  listActiveWorktrees() {
+    return Array.from(this.activeWorktrees.values());
+  }
+  /**
+   * Cleans up all active worktrees
+   *
+   * This method should be called during application shutdown to ensure
+   * all worktrees are properly cleaned up.
+   *
+   * @param force - Force removal even if there are uncommitted changes
+   */
+  async cleanupAll(force = false) {
+    if (!this.enabled) {
+      return;
+    }
+    logger.info("Cleaning up all worktrees");
+    const workers = Array.from(this.activeWorktrees.keys());
+    const results = await Promise.allSettled(
+      workers.map((workerId) => this.removeWorktree(workerId, force))
+    );
+    const failures = results.filter((r) => r.status === "rejected");
+    if (failures.length > 0) {
+      logger.error(`Failed to cleanup ${failures.length} worktrees`);
+    } else {
+      logger.info("Successfully cleaned up all worktrees");
+    }
+  }
+  /**
+   * Parses the output of 'git worktree list --porcelain'
+   *
+   * @param output - Raw output from git worktree list
+   * @returns Array of worktree paths
+   */
+  parseWorktreeList(output2) {
+    const lines = output2.split("\n");
+    const paths = [];
+    for (const line of lines) {
+      if (line.startsWith("worktree ")) {
+        paths.push(line.substring("worktree ".length));
+      }
+    }
+    return paths;
+  }
+  /**
+   * Checks if the repository is in a clean state for worktree operations
+   *
+   * @returns True if repository is clean
+   */
+  async isRepositoryClean() {
+    const status = await this.git.status();
+    return status.files.length === 0;
+  }
+};
+
+// src/config/omnara-config.ts
+import { parse as parseJsonc } from "jsonc-parser";
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
+import * as z2 from "zod";
+var OmnaraConfig = z2.object({
+  worktrees: z2.object({
+    enabled: z2.boolean().default(false)
+  }).default({
+    enabled: false
+  })
+});
+async function readOmnaraConfig(configPath) {
+  const resolveConfig = async (path7) => {
+    if (!path7) {
+      return null;
+    }
+    await fs5.access(path7);
+    const content = await fs5.readFile(path7, "utf-8");
+    const errors = [];
+    const config = parseJsonc(content, errors, {
+      allowTrailingComma: true,
+      allowEmptyContent: true
+    });
+    return OmnaraConfig.parse(config);
+  };
+  const resolveDefault = () => {
+    return OmnaraConfig.parse({});
+  };
+  return await resolveConfig(configPath).catch(() => null) ?? await resolveConfig(path5.join(process.cwd(), "omnara.jsonc")).catch(() => null) ?? await resolveConfig(path5.join(process.cwd(), "omnara.json")).catch(() => null) ?? await resolveDefault();
+}
+function isWorktreesEnabled(config) {
+  return config.worktrees.enabled;
+}
+
 // src/orchestrator/worker-manager.ts
 var WorkerManager = class extends EventEmitter {
   constructor(options) {
     super();
     this.options = options;
+    this.worktreeManager = new WorktreeManager({
+      repoPath: options.repoPath,
+      enabled: false
+    });
+    this.initializeConfig();
+  }
+  workers = /* @__PURE__ */ new Map();
+  runningQueries = /* @__PURE__ */ new Map();
+  worktreeManager;
+  configInitialized = false;
+  /**
+   * Initialize the configuration and update WorktreeManager accordingly
+   */
+  async initializeConfig() {
+    try {
+      const config = await readOmnaraConfig();
+      const worktreesEnabled = isWorktreesEnabled(config);
+      if (worktreesEnabled) {
+        logger.info("Worktrees enabled via omnara.jsonc configuration");
+      } else {
+        logger.info("Worktrees disabled (no worktrees config found in omnara.jsonc)");
+      }
+      this.worktreeManager = new WorktreeManager({
+        repoPath: this.options.repoPath,
+        enabled: worktreesEnabled
+      });
+      this.configInitialized = true;
+    } catch (err) {
+      logger.error("Failed to read omnara.jsonc configuration:", err);
+      logger.info("Worktrees disabled due to config read error");
+      this.configInitialized = true;
+    }
   }
-  workers = /* @__PURE__ */ new Map();
-  runningQueries = /* @__PURE__ */ new Map();
   listWorkers() {
     return Array.from(this.workers.values());
   }
@@ -589,7 +1222,7 @@ var WorkerManager = class extends EventEmitter {
     }
     return lines.join("\n");
   }
-  launchWorker({ task, prompt: prompt2, originSessionId, metadata }) {
+  launchWorker({ task, prompt: prompt2, work_context, worktree_name, originSessionId, metadata }, toolUseId) {
     const sessionId = randomUUID2();
     const resolvedOriginSessionId = originSessionId;
     const record = {
@@ -604,14 +1237,81 @@ var WorkerManager = class extends EventEmitter {
       originSessionId: resolvedOriginSessionId,
       progress: [],
       metadata,
-      messageQueue: new AsyncQueue()
+      messageQueue: new AsyncQueue(),
+      work_context,
+      worktree_name
     };
     this.workers.set(sessionId, record);
     this.emit("session_start", { ...record });
     this.emitUpdate(record);
-    void this.runWorker(record, prompt2);
+    if (toolUseId) {
+      this.emit("message", {
+        record,
+        messageType: "tool_call",
+        toolName: "mcp__worker__launch_worker",
+        toolUseId,
+        toolInput: { task, prompt: prompt2, metadata }
+      });
+      this.emit("message", {
+        record,
+        messageType: "tool_result",
+        toolUseId,
+        toolContent: {
+          workerId: record.id,
+          status: record.status,
+          message: `Worker launched successfully, task ${task} in progress.`
+        },
+        isError: false
+      });
+    }
+    void this.createWorktreeAndRun(record, prompt2);
     return record;
   }
+  async createWorktreeAndRun(record, prompt2) {
+    try {
+      if (this.worktreeManager.isEnabled()) {
+        logger.info(`Creating worktree for worker ${record.id} (task: ${record.task})`);
+        const worktreeInfo = await this.worktreeManager.createWorktree(
+          record.id,
+          record.worktree_name || record.id
+        );
+        record.worktreePath = worktreeInfo.worktreePath;
+        record.branchName = worktreeInfo.branchName;
+        record.progress.push({
+          timestamp: Date.now(),
+          message: `Worktree created at ${worktreeInfo.worktreePath} on branch ${worktreeInfo.branchName}`
+        });
+        this.emitUpdate(record);
+        logger.info(`Worktree created for worker ${record.id} at ${worktreeInfo.worktreePath}`);
+      } else {
+        logger.info(`Worktrees disabled, worker ${record.id} will run in current directory`);
+        record.progress.push({
+          timestamp: Date.now(),
+          message: "Worktrees disabled, running in current directory"
+        });
+        this.emitUpdate(record);
+      }
+      await this.runWorker(record, prompt2);
+    } catch (error) {
+      logger.error(`Failed to setup worker ${record.id}:`, error);
+      record.status = "error";
+      record.error = `Failed to setup worker: ${error instanceof Error ? error.message : String(error)}`;
+      record.lastUpdateAt = Date.now();
+      record.progress.push({
+        timestamp: Date.now(),
+        message: `Worker failed: ${record.error}`
+      });
+      this.emitUpdate(record);
+      this.emit("message", {
+        record,
+        messageType: "assistant_complete",
+        success: false,
+        text: record.error
+      });
+      this.emitCompleted(record);
+      record.messageQueue.close();
+    }
+  }
   cancelWorker(id) {
     const record = this.workers.get(id);
     if (!record) {
@@ -642,19 +1342,41 @@ var WorkerManager = class extends EventEmitter {
     return true;
   }
   /**
-   * Send a message to a running worker.
+   * Send a message to a worker (running or completed).
    *
    * @param task - The task name of the worker to message
    * @param message - The message content to send
    * @param interrupt - If true, interrupt current generation; if false, queue for next turn
-   * @returns true if message was sent, false if worker not found or not running
+   * @param toolUseId - Optional tool use ID to track this operation for relay forwarding
+   * @returns true if message was sent, false if worker not found or message queue is closed
    */
-  async messageWorker(task, message, interrupt) {
+  async messageWorker(task, message, interrupt, toolUseId) {
     const record = this.getWorkerByTask(task);
     if (!record) {
       return false;
     }
+    if (toolUseId) {
+      this.emit("message", {
+        record,
+        messageType: "tool_call",
+        toolName: "mcp__worker__message_worker",
+        toolUseId,
+        toolInput: { task, message, interrupt }
+      });
+    }
     if (record.status !== "running") {
+      record.messageQueue = new AsyncQueue();
+      record.status = "running";
+      record.lastUpdateAt = Date.now();
+      record.progress.push({
+        timestamp: Date.now(),
+        message: `Worker restarted with new message: ${message}`
+      });
+      this.emitUpdate(record);
+      void this.runWorker(record, "");
+    }
+    if (record.messageQueue.isClosed()) {
+      console.error("[WorkerManager] Message queue is closed after restart attempt");
       return false;
     }
     record.progress.push({
@@ -684,9 +1406,35 @@ var WorkerManager = class extends EventEmitter {
     };
     try {
       record.messageQueue.push(userMessage);
+      if (toolUseId) {
+        this.emit("message", {
+          record,
+          messageType: "tool_result",
+          toolUseId,
+          toolContent: {
+            success: true,
+            task,
+            interrupted: interrupt,
+            message: interrupt ? `Message sent to worker "${task}" (interrupted current work)` : `Message queued for worker "${task}" (will be delivered after current turn)`
+          },
+          isError: false
+        });
+      }
       return true;
     } catch (error) {
       console.error("[WorkerManager] Failed to queue message:", error);
+      if (toolUseId) {
+        this.emit("message", {
+          record,
+          messageType: "tool_result",
+          toolUseId,
+          toolContent: {
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to queue message"
+          },
+          isError: true
+        });
+      }
       return false;
     }
   }
@@ -713,17 +1461,20 @@ var WorkerManager = class extends EventEmitter {
   /**
    * Create an async iterable stream of user messages for the worker.
    * Yields the initial prompt, then streams any additional messages from the queue.
+   * If initialPrompt is empty, skips the initial yield and only consumes from the queue.
    */
   async *createMessageStream(initialPrompt, sessionId, messageQueue) {
-    yield {
-      session_id: sessionId,
-      type: "user",
-      message: {
-        role: "user",
-        content: initialPrompt
-      },
-      parent_tool_use_id: null
-    };
+    if (initialPrompt.trim()) {
+      yield {
+        session_id: sessionId,
+        type: "user",
+        message: {
+          role: "user",
+          content: initialPrompt
+        },
+        parent_tool_use_id: null
+      };
+    }
     for await (const message of messageQueue) {
       yield message;
     }
@@ -735,12 +1486,17 @@ var WorkerManager = class extends EventEmitter {
     console.log("[WorkerManager] Creating worker client with status MCP server:", {
       workerId: record.id,
       task: record.task,
-      hasMcpServer: !!statusMcpServer
-    });
-    const client = this.options.createClient({
-      worker_status: statusMcpServer
+      hasMcpServer: !!statusMcpServer,
+      worktreePath: record.worktreePath,
+      branchName: record.branchName
     });
-    const workerPrompt = this.wrapPrompt(prompt2);
+    const client = this.options.createClient(
+      {
+        worker_status: statusMcpServer
+      },
+      record.worktreePath
+    );
+    const workerPrompt = this.wrapPrompt(prompt2, record.worktreePath, record.branchName);
     const messageStream = this.createMessageStream(
       workerPrompt,
       record.sessionId,
@@ -827,7 +1583,6 @@ var WorkerManager = class extends EventEmitter {
       });
       this.emitCompleted(record);
     } finally {
-      record.messageQueue.close();
       this.runningQueries.delete(record.id);
     }
   }
@@ -960,22 +1715,58 @@ var WorkerManager = class extends EventEmitter {
       return "Unknown worker error";
     }
   }
-  wrapPrompt(userPrompt) {
-    const directive = `
+  wrapPrompt(userPrompt, worktreePath, branchName) {
+    let directive = `
 
 IMPORTANT:
 - Use the mcp__worker_status__send_status_update tool to report progress as you work.
 - When finished, output a final summary.
 - Do not include raw diffs or large file dumps unless explicitly asked.
 `;
+    if (worktreePath && branchName) {
+      directive += `
+WORKTREE ISOLATION:
+- You are working in an isolated git worktree at: ${worktreePath}
+- Your dedicated branch is: ${branchName}
+- All your file operations, git commands, and changes are isolated to this worktree.
+- Other workers cannot see your changes and you cannot see theirs.
+- When you're done, your worktree will be automatically cleaned up.
+
+COMMIT YOUR CHANGES:
+- Before completing your task, commit your changes using git.
+- Use a descriptive commit message that explains what you did.
+- Your commits will stay on your isolated branch and can be reviewed before merging.
+- This ensures your work is preserved even if cleanup happens unexpectedly.
+`;
+    }
     return `${userPrompt.trim()}
 ${directive}`;
   }
+  /**
+   * Shutdown the worker manager and cleanup all resources
+   * This should be called during application shutdown to ensure all worktrees are cleaned up
+   */
+  async shutdown() {
+    logger.info("Shutting down worker manager");
+    const runningWorkers = Array.from(this.workers.values()).filter((w) => w.status === "running");
+    for (const worker of runningWorkers) {
+      logger.info(`Canceling worker ${worker.id} during shutdown`);
+      this.cancelWorker(worker.id);
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+    try {
+      await this.worktreeManager.cleanupAll(true);
+      logger.info("All worktrees cleaned up successfully");
+    } catch (error) {
+      logger.error("Error during worktree cleanup:", error);
+    }
+    logger.info("Worker manager shutdown complete");
+  }
 };
 
 // src/orchestrator/tools/worker-tools.ts
 import { createSdkMcpServer as createSdkMcpServer2, tool as tool2 } from "@anthropic-ai/claude-agent-sdk";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
 function createWorkerMcpServer(workerManager, context) {
   return createSdkMcpServer2({
     name: "worker",
@@ -983,7 +1774,13 @@ function createWorkerMcpServer(workerManager, context) {
     tools: [
       tool2(
         "launch_worker",
-        `Launch a background worker agent to handle tasks autonomously.
+        `Launch a background worker agent to handle tasks autonomously in an isolated git worktree.
+
+Each worker operates in its own git worktree, providing complete isolation:
+- Separate working directory (no shared file changes)
+- Dedicated git branch
+- Independent git operations (staging, committing, etc.)
+- The worker's worktree is automatically cleaned up when the worker completes
 
 When to use this tool:
 - Complex tasks requiring multiple steps or operations
@@ -999,11 +1796,14 @@ Usage notes:
 - The worker's result is returned to you, not the user - you must summarize or forward relevant information
 - Worker progress status is automatically included in your context - you can see their current state without additional tools`,
         {
-          task: z2.string().min(1, "task name is required").describe(
+          task: z3.string().min(1, "task name is required").describe(
             'A short, unique name for this task (e.g., "FizzBuzz Python", "Search codebase", "Fix bug #123"). Used to identify and track this worker.'
           ),
-          prompt: z2.string().min(1, "prompt is required"),
-          metadata: z2.record(z2.any()).optional()
+          prompt: z3.string().min(1, "prompt is required"),
+          worktree_name: z3.string().min(1, "worktree_name is required").describe(
+            "A short descriptive name for a worktree to create that can be used by workers simultaneously. This is synonymous with branch."
+          ),
+          metadata: z3.record(z3.any()).optional()
         },
         async (args, extra) => {
           const typedExtra = extra;
@@ -1024,14 +1824,20 @@ Usage notes:
           console.log("[WorkerTools] Launching worker:", {
             task: args.task,
             parentSessionId,
-            mainCodingSession: context.getMainCodingSessionId()
-          });
-          const record = workerManager.launchWorker({
-            task: args.task,
-            prompt: args.prompt,
-            originSessionId: parentSessionId,
-            metadata: args.metadata
+            mainCodingSession: context.getMainCodingSessionId(),
+            toolUseId
           });
+          const record = workerManager.launchWorker(
+            {
+              task: args.task,
+              prompt: args.prompt,
+              work_context: args.worktree_name,
+              worktree_name: args.worktree_name,
+              originSessionId: parentSessionId,
+              metadata: args.metadata
+            },
+            toolUseId
+          );
           return {
             content: [
               {
@@ -1039,6 +1845,8 @@ Usage notes:
                 text: JSON.stringify({
                   workerId: record.id,
                   status: record.status,
+                  worktree_path: record.worktreePath,
+                  branch_name: record.branchName,
                   message: `Worker launched successfully, task ${args.task} in progress. You will be notified for progress updates.`
                 })
               }
@@ -1093,19 +1901,29 @@ Orchestrator: [launches worker: "refactor database"]
 User: "Wait, actually don't touch the database - just refactor the API layer instead"
 Orchestrator: [message_worker: task="refactor database", message="User wants to change scope - refactor API layer instead, leave database alone", interrupt=true]`,
         {
-          task: z2.string().min(1, "task name is required").describe("The task name of the worker to message"),
-          message: z2.string().min(1, "message is required").describe(
+          task: z3.string().min(1, "task name is required").describe("The task name of the worker to message"),
+          message: z3.string().min(1, "message is required").describe(
             "The message to send to the worker. Be clear and specific about what has changed or what additional context is being provided."
           ),
-          interrupt: z2.boolean().default(false).describe(
+          interrupt: z3.boolean().default(false).describe(
             "If true, interrupt current generation immediately; if false (default), queue message for next turn"
           )
         },
-        async (args) => {
+        async (args, extra) => {
+          const typedExtra = extra;
+          const toolUseIdRaw = typedExtra?._meta?.["claudecode/toolUseId"];
+          const toolUseId = typeof toolUseIdRaw === "string" ? toolUseIdRaw : void 0;
+          console.log("[WorkerTools] Messaging worker:", {
+            task: args.task,
+            message: args.message.substring(0, 100),
+            interrupt: args.interrupt,
+            toolUseId
+          });
           const success = await workerManager.messageWorker(
             args.task,
             args.message,
-            args.interrupt
+            args.interrupt,
+            toolUseId
           );
           if (!success) {
             const worker = workerManager.getWorkerByTask(args.task);
@@ -1176,15 +1994,17 @@ var AgentOrchestrator = class {
   started = false;
   constructor(dependencies) {
     const resolveSessionIdBySdk = (sdkSessionId) => this.findSessionIdBySdkSession(sdkSessionId);
-    const workerClientFactory = dependencies?.createWorkerClient ?? ((mcpServers) => new AIClient({
+    const workerClientFactory = dependencies?.createWorkerClient ?? ((mcpServers, cwd) => new AIClient({
       defaults: {
         allowedTools: [...BASE_ALLOWED_WORKER_TOOLS, "mcp__worker_status__send_status_update"],
-        mcpServers
+        mcpServers,
+        cwd: cwd || process.cwd()
       }
     }));
     this.workerManager = dependencies?.workerManager ?? new WorkerManager({
       createClient: workerClientFactory,
-      resolveSessionIdBySdk
+      resolveSessionIdBySdk,
+      repoPath: dependencies?.repoPath ?? process.cwd()
     });
     const workerMcpServer = createWorkerMcpServer(this.workerManager, {
       resolveSessionIdBySdk,
@@ -1273,6 +2093,7 @@ var AgentOrchestrator = class {
     this.started = true;
   }
   async stop() {
+    await this.workerManager.shutdown();
     for (const connection of Array.from(this.clients.values())) {
       this.handleDisconnect(connection);
       try {
@@ -1775,76 +2596,6 @@ var AgentOrchestrator = class {
   }
 };
 
-// src/auth/credentials-store.ts
-import fs3 from "fs/promises";
-import os2 from "os";
-import path2 from "path";
-var DEFAULT_DIR = path2.join(os2.homedir(), ".omnara");
-var DEFAULT_CREDENTIALS_PATH = path2.join(DEFAULT_DIR, "creds.json");
-var DEFAULT_FILE_MODE = 384;
-var DEFAULT_DIR_MODE = 448;
-function isStoredCredentials(value) {
-  return Boolean(value) && typeof value === "object";
-}
-var CredentialsStore = class {
-  constructor(filePath = DEFAULT_CREDENTIALS_PATH) {
-    this.filePath = filePath;
-  }
-  async load() {
-    try {
-      const raw = await fs3.readFile(this.filePath, "utf8");
-      const parsed = JSON.parse(raw);
-      if (!isStoredCredentials(parsed)) {
-        throw new Error("File does not contain valid credentials data");
-      }
-      return parsed;
-    } catch (error) {
-      if (isFileNotFound(error)) {
-        return null;
-      }
-      throw new Error(
-        `Failed to read credentials from ${this.filePath}: ${extractErrorMessage2(error)}`
-      );
-    }
-  }
-  async save(credentials) {
-    const payload = {
-      accessToken: credentials.accessToken,
-      accessTokenExpiresAt: credentials.accessTokenExpiresAt,
-      refreshToken: credentials.refreshToken,
-      refreshTokenExpiresAt: credentials.refreshTokenExpiresAt
-    };
-    await fs3.mkdir(path2.dirname(this.filePath), { recursive: true, mode: DEFAULT_DIR_MODE });
-    const tempPath = `${this.filePath}.tmp`;
-    const serialized = JSON.stringify(payload, null, 2);
-    await fs3.writeFile(tempPath, serialized, { mode: DEFAULT_FILE_MODE });
-    await fs3.chmod(tempPath, DEFAULT_FILE_MODE);
-    await fs3.rename(tempPath, this.filePath);
-  }
-  async clear() {
-    try {
-      await fs3.unlink(this.filePath);
-    } catch (error) {
-      if (!isFileNotFound(error)) {
-        throw new Error(
-          `Failed to remove credentials file ${this.filePath}: ${extractErrorMessage2(error)}`
-        );
-      }
-    }
-  }
-};
-function isFileNotFound(error) {
-  return Boolean(
-    error && typeof error === "object" && "code" in error && error.code === "ENOENT"
-  );
-}
-function extractErrorMessage2(error) {
-  if (error instanceof Error && error.message) {
-    return error.message;
-  }
-  return String(error);
-}
-
 // src/relay/relay-bridge.ts
 import { randomUUID as randomUUID4 } from "crypto";
 import EventEmitter2 from "events";
@@ -1865,8 +2616,8 @@ var ApiClient = class {
   constructor(options) {
     this.baseUrl = normalizeBaseUrl(options.baseUrl);
   }
-  async getJson(path5, options) {
-    const url = resolveUrl(this.baseUrl, path5);
+  async getJson(path7, options) {
+    const url = resolveUrl(this.baseUrl, path7);
     const headers = this.buildHeaders(options);
     const response = await fetch(url, {
       method: "GET",
@@ -1875,8 +2626,8 @@ var ApiClient = class {
     });
     return await this.handleResponse(response);
   }
-  async postJson(path5, body, options) {
-    const url = resolveUrl(this.baseUrl, path5);
+  async postJson(path7, body, options) {
+    const url = resolveUrl(this.baseUrl, path7);
     const headers = this.buildHeaders(options, { includeJson: true });
     const response = await fetch(url, {
       method: "POST",
@@ -1914,7 +2665,7 @@ var ApiClient = class {
         if (response.ok) {
           throw new ApiError(
             response.status,
-            `Failed to parse JSON response: ${extractErrorMessage3(error)}`
+            `Failed to parse JSON response: ${extractErrorMessage4(error)}`
           );
         }
       }
@@ -1934,12 +2685,12 @@ function normalizeBaseUrl(raw) {
   }
   return raw.endsWith("/") ? raw : `${raw}/`;
 }
-function resolveUrl(base, path5) {
+function resolveUrl(base, path7) {
   const baseUrl = new URL(base);
-  if (!path5.startsWith("/")) {
-    path5 = `/${path5}`;
+  if (!path7.startsWith("/")) {
+    path7 = `/${path7}`;
   }
-  const resolved = new URL(path5, baseUrl);
+  const resolved = new URL(path7, baseUrl);
   return resolved.toString();
 }
 function extractDetail(payload) {
@@ -1962,7 +2713,7 @@ function extractDetail(payload) {
   }
   return null;
 }
-function extractErrorMessage3(error) {
+function extractErrorMessage4(error) {
   if (error instanceof Error) {
     return error.message;
   }
@@ -2480,14 +3231,14 @@ function reportLoopbackError(error) {
     );
     return;
   }
-  console.log(`Automatic login failed: ${extractErrorMessage4(error)}`);
+  console.log(`Automatic login failed: ${extractErrorMessage5(error)}`);
 }
 function printSessionInstructions(session) {
   console.log("\nOpen this link in your browser if it did not open automatically:");
   console.log(`  ${session.verificationUriComplete}`);
   console.log("Approve the request, then return to the CLI.");
 }
-function extractErrorMessage4(error) {
+function extractErrorMessage5(error) {
   if (error instanceof Error && error.message) {
     return error.message;
   }
@@ -2510,7 +3261,7 @@ async function waitForLoopback(listener, sessionId, onCode) {
       reportLoopbackError(error);
     }
   } catch (error) {
-    console.log(`Loopback listener error: ${extractErrorMessage4(error)}`);
+    console.log(`Loopback listener error: ${extractErrorMessage5(error)}`);
   }
 }
 
@@ -4458,6 +5209,58 @@ var api_billing_subscription_response_schema_default = {
       ],
       default: null,
       title: "Provider"
+    },
+    plan_display_name: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "Human-friendly plan label (e.g. Pro, Starter).",
+      title: "Plan Display Name"
+    },
+    plan_price_amount: {
+      anyOf: [
+        {
+          type: "number"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "Recurring charge amount for the plan (in major currency units).",
+      title: "Plan Price Amount"
+    },
+    plan_price_currency: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "ISO currency for the recurring charge (e.g. usd).",
+      title: "Plan Price Currency"
+    },
+    plan_price_interval: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "Billing interval for the recurring charge (e.g. month, year).",
+      title: "Plan Price Interval"
     }
   },
   required: [
@@ -4647,9 +5450,79 @@ var api_billing_promo_validation_response_schema_default = {
       default: null,
       title: "Description"
     },
-    error: {
+    error: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      title: "Error"
+    }
+  },
+  required: [
+    "valid"
+  ],
+  type: "object"
+};
+
+// ../shared-js/schemas/api_billing_customer_portal_request.schema.json
+var api_billing_customer_portal_request_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.omnara.dev/CustomerPortalSessionRequest",
+  title: "CustomerPortalSessionRequest",
+  description: "Request to create a Stripe Billing customer portal session.",
+  properties: {
+    return_url: {
+      anyOf: [
+        {
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "Where Stripe should send the customer after they leave the portal.",
+      title: "Return Url"
+    }
+  },
+  type: "object"
+};
+
+// ../shared-js/schemas/api_billing_customer_portal_response.schema.json
+var api_billing_customer_portal_response_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://schemas.omnara.dev/CustomerPortalSessionResponse",
+  title: "CustomerPortalSessionResponse",
+  description: "Response containing the Stripe Billing customer portal session URL.",
+  properties: {
+    url: {
+      description: "Hosted Stripe customer portal URL.",
+      title: "Url",
+      type: "string"
+    },
+    created: {
+      anyOf: [
+        {
+          format: "date-time",
+          type: "string"
+        },
+        {
+          type: "null"
+        }
+      ],
+      default: null,
+      description: "Timestamp when the session was created.",
+      title: "Created"
+    },
+    expires_at: {
       anyOf: [
         {
+          format: "date-time",
           type: "string"
         },
         {
@@ -4657,11 +5530,12 @@ var api_billing_promo_validation_response_schema_default = {
         }
       ],
       default: null,
-      title: "Error"
+      description: "When the portal session expires (if provided by Stripe).",
+      title: "Expires At"
     }
   },
   required: [
-    "valid"
+    "url"
   ],
   type: "object"
 };
@@ -4801,6 +5675,8 @@ var validateCreateCheckoutSessionRequest = ajv.compile(api_billing_create_checko
 var validateCheckoutSessionResponse = ajv.compile(api_billing_checkout_response_schema_default);
 var validateValidatePromoCodeRequest = ajv.compile(api_billing_validate_promo_request_schema_default);
 var validatePromoCodeValidationResponse = ajv.compile(api_billing_promo_validation_response_schema_default);
+var validateCustomerPortalSessionRequest = ajv.compile(api_billing_customer_portal_request_schema_default);
+var validateCustomerPortalSessionResponse = ajv.compile(api_billing_customer_portal_response_schema_default);
 var validateUserNotificationSettingsRequest = ajv.compile(api_settings_notification_request_schema_default);
 var validateUserNotificationSettingsResponse = ajv.compile(api_settings_notification_response_schema_default);
 
@@ -4855,7 +5731,7 @@ var RelayBridge = class extends EventEmitter2 {
           break;
         }
         this.logger.error(
-          `Relay connection failed: ${extractErrorMessage5(error)}. Retrying in ${Math.round(backoffMs / 1e3)}s.`
+          `Relay connection failed: ${extractErrorMessage6(error)}. Retrying in ${Math.round(backoffMs / 1e3)}s.`
         );
         await delay(backoffMs);
         backoffMs = Math.min(backoffMs * 2, 3e4);
@@ -4978,7 +5854,7 @@ var RelayBridge = class extends EventEmitter2 {
         target.send(serialized);
         return;
       } catch (error) {
-        this.logger.error(`Failed to send relay frame: ${extractErrorMessage5(error)}`);
+        this.logger.error(`Failed to send relay frame: ${extractErrorMessage6(error)}`);
         if (target === this.ws) {
           this.closeCurrentSocket();
         }
@@ -5037,7 +5913,7 @@ var RelayBridge = class extends EventEmitter2 {
       const text = typeof data === "string" ? data : data.toString("utf8");
       parsed = JSON.parse(text);
     } catch (error) {
-      this.logger.error(`Received invalid JSON from relay: ${extractErrorMessage5(error)}`);
+      this.logger.error(`Received invalid JSON from relay: ${extractErrorMessage6(error)}`);
       return;
     }
     if (this.tryHandleControlMessage(parsed)) {
@@ -5067,6 +5943,8 @@ var RelayBridge = class extends EventEmitter2 {
         }
         return frame;
       }
+      case "user_text":
+        return this.buildUserTextEnvelope(message);
       case "assistant_text":
         return this.buildTextEnvelope(message);
       case "tool_call":
@@ -5212,6 +6090,30 @@ var RelayBridge = class extends EventEmitter2 {
   isTextContent(content) {
     return typeof content.text === "string";
   }
+  buildUserTextEnvelope(message) {
+    const content = {
+      type: "text",
+      text: message.text
+    };
+    const payloadMetadata = message.workerId || message.workerTask ? {
+      worker_id: message.workerId,
+      worker_task: message.workerTask
+    } : void 0;
+    const senderSessionId = message.workerId ?? message.sessionId;
+    const envelope = this.buildEnvelope({
+      sessionId: message.sessionId,
+      senderSessionId,
+      content,
+      payloadMetadata,
+      messageId: message.messageId
+    });
+    envelope.metadata = {
+      ...envelope.metadata,
+      role: "user",
+      transport: "relay"
+    };
+    return envelope;
+  }
   buildTextEnvelope(message) {
     const content = {
       type: "text",
@@ -5379,7 +6281,7 @@ var RelayBridge = class extends EventEmitter2 {
       try {
         this.ws.send(payload);
       } catch (error) {
-        this.logger.error(`Failed to flush relay queue: ${extractErrorMessage5(error)}`);
+        this.logger.error(`Failed to flush relay queue: ${extractErrorMessage6(error)}`);
         this.pendingOutbound.unshift(payload);
         this.closeCurrentSocket();
         break;
@@ -5410,23 +6312,23 @@ var RelayBridge = class extends EventEmitter2 {
     }
   }
 };
-function buildRelayWebsocketUrl(baseUrl, path5) {
+function buildRelayWebsocketUrl(baseUrl, path7) {
   const url = new URL(baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   url.search = "";
   url.hash = "";
-  if (path5.startsWith("/")) {
-    url.pathname = path5;
+  if (path7.startsWith("/")) {
+    url.pathname = path7;
   } else {
     const basePath = url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`;
-    url.pathname = `${basePath}${path5}`;
+    url.pathname = `${basePath}${path7}`;
   }
   return url.toString();
 }
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function extractErrorMessage5(error) {
+function extractErrorMessage6(error) {
   if (error instanceof Error) {
     return error.message;
   }
@@ -5762,7 +6664,7 @@ Commands:
 
 // src/voice/voice-service.ts
 async function launchVoiceForSession(client, accessToken, options) {
-  const path5 = `/api/v1/voice/sessions/${options.sessionId}/launch`;
+  const path7 = `/api/v1/voice/sessions/${options.sessionId}/launch`;
   const requestBody = {};
   if (options.force) {
     requestBody.force = true;
@@ -5771,7 +6673,7 @@ async function launchVoiceForSession(client, accessToken, options) {
     requestBody.room_name = options.roomName;
   }
   const response = await client.postJson(
-    path5,
+    path7,
     requestBody,
     { accessToken }
   );
@@ -5796,50 +6698,47 @@ function checkClaudeCodeInstallation() {
   try {
     execSync("claude --version", {
       stdio: "ignore",
-      encoding: "utf-8"
+      encoding: "utf-8",
+      env: process.env
     });
     return true;
   } catch {
     return false;
   }
 }
+function checkAnthropicApiKey() {
+  return !!process.env.ANTHROPIC_API_KEY && process.env.ANTHROPIC_API_KEY.trim().length > 0;
+}
 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.")
+    chalk.yellow(
+      "\nWarning: Omnara needs access to the Anthropic API. Omnara didn't detect claude installed, nor did it find a valid API key. If you run into authentication errors, login via `claude login` or pass in an ANTHROPIC_API_KEY as an environment variable.\n"
+    )
   );
-  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) {
+  const isClaudeInstalled = checkClaudeCodeInstallation();
+  const hasApiKey = checkAnthropicApiKey();
+  const hasAuthentication = isClaudeInstalled || hasApiKey;
+  if (!hasAuthentication && !silent) {
     displayClaudeCodeWarning();
     if (exitOnMissing) {
-      console.error(chalk.red("Exiting: Claude Code is required for this operation."));
+      console.error(chalk.red("Exiting: Authentication is required for this operation."));
       process.exit(1);
     }
   }
-  return isInstalled;
+  return hasAuthentication;
 }
 function getClaudeCodeVersion() {
   try {
     const version = execSync("claude --version", {
       encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"]
+      stdio: ["ignore", "pipe", "ignore"],
+      env: process.env
     }).trim();
     return version;
   } catch {
@@ -5847,233 +6746,6 @@ function getClaudeCodeVersion() {
   }
 }
 
-// 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 */)) {
-      const consoleWithProfile = this._console;
-      consoleWithProfile.profile?.(label);
-    }
-  }
-  profileEnd(label) {
-    if (this.shouldLog(4 /* DEBUG */)) {
-      const consoleWithProfileEnd = this._console;
-      consoleWithProfileEnd.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(
@@ -6118,7 +6790,7 @@ async function runAgentOrchestrator(options = {}) {
   try {
     await bridge.start();
   } catch (error) {
-    logger.error(`Relay orchestrator terminated: ${extractErrorMessage6(error)}`);
+    logger.error(`Relay orchestrator terminated: ${extractErrorMessage2(error)}`);
     process.exitCode = process.exitCode || 1;
   } finally {
     await stop();
@@ -6203,16 +6875,16 @@ async function runVoice(options) {
   logger.debug(launch.relayToken);
   logger.important("\nKeep this information secure\u2014tokens grant access to your agent session.");
 }
-function buildRelayWebsocketUrl2(baseUrl, path5) {
+function buildRelayWebsocketUrl2(baseUrl, path7) {
   const url = new URL(baseUrl);
   url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
   url.search = "";
   url.hash = "";
-  if (path5.startsWith("/")) {
-    url.pathname = path5;
+  if (path7.startsWith("/")) {
+    url.pathname = path7;
   } else {
     const basePath = url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`;
-    url.pathname = `${basePath}${path5}`;
+    url.pathname = `${basePath}${path7}`;
   }
   return url.toString();
 }
@@ -6385,9 +7057,9 @@ function isMainModule() {
   if (!import.meta.url || !process.argv[1]) {
     return false;
   }
-  const executedPath = path4.resolve(process.argv[1]);
+  const executedPath = path6.resolve(process.argv[1]);
   const currentPath = import.meta.url.startsWith("file://") ? decodeURIComponent(import.meta.url.slice(7)) : import.meta.url;
-  return path4.normalize(currentPath) === path4.normalize(executedPath);
+  return path6.normalize(currentPath) === path6.normalize(executedPath);
 }
 if (isMainModule()) {
   run(process.argv).catch((error) => {