omnara 0.2.0 → 0.2.2

package/dist/cli.js

@@ -107,8 +107,22 @@ import { randomUUID } from "crypto";
 import fs2 from "fs";
 import path from "path";
 import os from "os";
+function isDevelopmentMode() {
+  if (process.env.OMNARA_ENV === "development") {
+    return true;
+  }
+  const backendUrl = process.env.OMNARA_BACKEND_URL;
+  if (backendUrl && (backendUrl.includes("localhost") || backendUrl.includes("127.0.0.1"))) {
+    return true;
+  }
+  return false;
+}
 function getLogDir() {
-  return process.env.OMNARA_LOG_DIR ?? path.join(os.homedir(), ".omnara", "omnara-voice");
+  if (process.env.OMNARA_LOG_DIR) {
+    return process.env.OMNARA_LOG_DIR;
+  }
+  const dirName = isDevelopmentMode() ? ".omnara-dev" : ".omnara";
+  return path.join(os.homedir(), dirName, "omnara-voice");
 }
 function ensureLogDir() {
   const dir = getLogDir();
@@ -784,7 +798,21 @@ import fs3 from "fs/promises";
 import os2 from "os";
 import path3 from "path";
 import { setTimeout as delay } from "node:timers/promises";
-var DEFAULT_DIR = path3.join(os2.homedir(), ".omnara");
+function isDevelopmentMode2() {
+  if (process.env.OMNARA_ENV === "development") {
+    return true;
+  }
+  const backendUrl = process.env.OMNARA_BACKEND_URL;
+  if (backendUrl && (backendUrl.includes("localhost") || backendUrl.includes("127.0.0.1"))) {
+    return true;
+  }
+  return false;
+}
+function getOmnaraHomeDir() {
+  const dirName = isDevelopmentMode2() ? ".omnara-dev" : ".omnara";
+  return path3.join(os2.homedir(), dirName);
+}
+var DEFAULT_DIR = getOmnaraHomeDir();
 var DEFAULT_CREDENTIALS_PATH = path3.join(DEFAULT_DIR, "creds.json");
 var DEFAULT_FILE_MODE = 384;
 var DEFAULT_DIR_MODE = 448;
@@ -1546,6 +1574,70 @@ var WorkerManager = class extends EventEmitter {
     record.messageQueue.close();
     return true;
   }
+  /**
+   * Route a user message to a worker by session ID.
+   * This is used when users send messages directly to subagent sessions from the frontend.
+   *
+   * @param sessionId - The session ID of the worker
+   * @param message - The message content to send
+   * @returns true if message was sent, false if worker not found
+   */
+  async routeUserMessageToWorker(sessionId, message) {
+    const record = this.workers.get(sessionId);
+    if (!record) {
+      console.error("[WorkerManager] Worker not found for session:", sessionId);
+      return false;
+    }
+    console.log("[WorkerManager] Routing user message to worker:", {
+      workerId: record.id,
+      task: record.task,
+      sessionId,
+      textPreview: message.substring(0, 100)
+    });
+    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 user 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({
+      timestamp: Date.now(),
+      message: `[USER MESSAGE]: ${message}`
+    });
+    record.lastUpdateAt = Date.now();
+    const userMessage = {
+      session_id: record.sessionId,
+      type: "user",
+      message: {
+        role: "user",
+        content: message
+      },
+      parent_tool_use_id: null,
+      isSynthetic: false
+      // This is a real user message from frontend
+    };
+    try {
+      record.messageQueue.push(userMessage);
+      console.log("[WorkerManager] Successfully queued user message to worker:", {
+        workerId: record.id,
+        task: record.task,
+        queueClosed: record.messageQueue.isClosed()
+      });
+      return true;
+    } catch (error) {
+      console.error("[WorkerManager] Failed to queue user message:", error);
+      return false;
+    }
+  }
   /**
    * Send a message to a worker (running or completed).
    *
@@ -1707,7 +1799,7 @@ var WorkerManager = class extends EventEmitter {
       record.sessionId,
       record.messageQueue
     );
-    const query4 = client.createQuery(messageStream, {
+    const queryOptions = {
       hooks: {
         PostToolUse: [
           {
@@ -1747,7 +1839,16 @@ var WorkerManager = class extends EventEmitter {
           }
         ]
       }
-    });
+    };
+    if (record.sdkSessionId) {
+      queryOptions.resume = record.sdkSessionId;
+      console.log("[WorkerManager] Resuming worker with SDK session ID:", {
+        workerId: record.id,
+        sdkSessionId: record.sdkSessionId,
+        task: record.task
+      });
+    }
+    const query4 = client.createQuery(messageStream, queryOptions);
     this.runningQueries.set(record.id, query4);
     const summarizedChunks = [];
     try {
@@ -1817,6 +1918,15 @@ Automatically committed changes from worker completion.`;
   }
   handleMessage(record, message, summarizedChunks) {
     switch (message.type) {
+      case "system":
+        if (message.subtype === "init" && message.session_id) {
+          record.sdkSessionId = message.session_id;
+          console.log("[WorkerManager] Captured SDK session ID for worker:", {
+            workerId: record.id,
+            sdkSessionId: record.sdkSessionId
+          });
+        }
+        break;
       case "assistant": {
         const text = this.extractAssistantText(message);
         if (text) {
@@ -2412,6 +2522,8 @@ var AgentOrchestrator = class {
   // Track voice sessions to filter out their messages
   voiceSessionIds = /* @__PURE__ */ new Set();
   // Made non-private for relay-bridge access
+  // Track worker sessions to filter out their messages (so they're handled by workers, not orchestrator)
+  workerSessionIds = /* @__PURE__ */ new Set();
   started = false;
   constructor(dependencies) {
     const resolveSessionIdBySdk = (sdkSessionId) => this.findSessionIdBySdkSession(sdkSessionId);
@@ -2591,6 +2703,21 @@ var AgentOrchestrator = class {
         currentVoiceSessions: Array.from(this.voiceSessionIds)
       });
     }
+    if (message.metadata?.session_type === "WORKER") {
+      this.workerSessionIds.add(message.sessionId);
+      console.log("[Orchestrator] Tracking worker session by type:", {
+        sessionId: message.sessionId,
+        metadata: message.metadata
+      });
+    }
+    if (message.parentSessionId && message.metadata?.session_type !== "VOICE") {
+      this.workerSessionIds.add(message.sessionId);
+      console.log("[Orchestrator] Tracking worker session from init:", {
+        sessionId: message.sessionId,
+        parentSessionId: message.parentSessionId,
+        currentWorkerSessions: Array.from(this.workerSessionIds)
+      });
+    }
     this.sendToConnection(connection, {
       type: "session_init_ack",
       sessionId: message.sessionId,
@@ -2598,18 +2725,31 @@ var AgentOrchestrator = class {
     });
   }
   handleChatMessage(connection, message) {
+    console.log("[Orchestrator] Routing check:", {
+      sessionId: message.sessionId,
+      workerSessionIds: Array.from(this.workerSessionIds),
+      isWorkerSession: message.sessionId ? this.workerSessionIds.has(message.sessionId) : false,
+      voiceSessionIds: Array.from(this.voiceSessionIds),
+      isVoiceSession: message.sessionId ? this.voiceSessionIds.has(message.sessionId) : false
+    });
     console.log("[Orchestrator] handleChatMessage:", {
       sessionId: message.sessionId,
       senderId: message.senderId,
       senderKind: message.senderKind,
       mainCodingSessionId: this.mainCodingSessionId,
       isVoiceSession: message.sessionId ? this.voiceSessionIds.has(message.sessionId) : false,
+      isWorkerSession: message.sessionId ? this.workerSessionIds.has(message.sessionId) : false,
       textPreview: message.text.substring(0, 100)
     });
     if (message.sessionId && this.voiceSessionIds.has(message.sessionId)) {
       console.log("[Orchestrator] Ignoring message to voice session:", message.sessionId);
       return;
     }
+    if (message.sessionId && this.workerSessionIds.has(message.sessionId)) {
+      console.log("[Orchestrator] Routing message to worker session:", message.sessionId);
+      this.routeMessageToWorker(message.sessionId, message.text);
+      return;
+    }
     let session;
     let sessionId = message.sessionId;
     if (sessionId) {
@@ -2694,6 +2834,17 @@ var AgentOrchestrator = class {
       });
     }
   }
+  /**
+   * Route a user message directly to a worker's message queue.
+   * This allows users to send messages to subagent sessions from the frontend.
+   */
+  routeMessageToWorker(sessionId, text) {
+    console.log("[Orchestrator] Routing message to worker session:", {
+      sessionId,
+      textPreview: text.substring(0, 100)
+    });
+    void this.workerManager.routeUserMessageToWorker(sessionId, text);
+  }
   createSession() {
     const sessionId = randomUUID3();
     return this.ensureSessionExists(sessionId);
@@ -2789,9 +2940,17 @@ var AgentOrchestrator = class {
     };
   }
   handleWorkerSessionStart(record) {
+    this.workerSessionIds.add(record.sessionId);
+    console.log("[Orchestrator] Tracking new worker session:", {
+      workerId: record.id,
+      sessionId: record.sessionId,
+      task: record.task,
+      currentWorkerSessions: Array.from(this.workerSessionIds)
+    });
     const metadata = {
       ...record.metadata,
-      task: record.task
+      task: record.task,
+      session_type: "WORKER"
     };
     this.broadcastToAll({
       type: "session_init",
@@ -2892,6 +3051,13 @@ var AgentOrchestrator = class {
     }
   }
   handleWorkerCompletion(record) {
+    console.log("[Orchestrator] Worker completed but keeping session tracked for routing:", {
+      workerId: record.id,
+      sessionId: record.sessionId,
+      task: record.task,
+      status: record.status,
+      currentWorkerSessions: Array.from(this.workerSessionIds)
+    });
     const sessionId = record.originSessionId;
     if (!sessionId) {
       return;
@@ -7841,6 +8007,21 @@ var RelayBridge = class extends EventEmitter2 {
         });
       }
     }
+    for (const agent of control.agent_sessions ?? []) {
+      if (agent.metadata?.session_type === "WORKER" || agent.parent_session_id) {
+        this.connectionHandle?.dispatch({
+          type: "session_init",
+          sessionId: agent.session_id,
+          parentSessionId: agent.parent_session_id ?? void 0,
+          metadata: { session_type: "WORKER", ...agent.metadata }
+        });
+        console.log("[RelayBridge] Dispatched worker session init from bootstrap:", {
+          sessionId: agent.session_id,
+          sessionType: agent.session_type,
+          parentSessionId: agent.parent_session_id
+        });
+      }
+    }
     for (const agent of control.agent_sessions ?? []) {
       this.orchestrator.ensureSessionExists(agent.session_id);
     }
@@ -8472,7 +8653,21 @@ import path8 from "node:path";
 import fs6 from "node:fs/promises";
 import os3 from "node:os";
 import path7 from "node:path";
-var OMNARA_HOME_DIR = path7.join(os3.homedir(), ".omnara");
+function isDevelopmentMode3() {
+  if (process.env.OMNARA_ENV === "development") {
+    return true;
+  }
+  const backendUrl = process.env.OMNARA_BACKEND_URL;
+  if (backendUrl && (backendUrl.includes("localhost") || backendUrl.includes("127.0.0.1"))) {
+    return true;
+  }
+  return false;
+}
+function getOmnaraHomeDir2() {
+  const dirName = isDevelopmentMode3() ? ".omnara-dev" : ".omnara";
+  return path7.join(os3.homedir(), dirName);
+}
+var OMNARA_HOME_DIR = getOmnaraHomeDir2();
 var DAEMON_CONFIG_PATH = path7.join(OMNARA_HOME_DIR, "daemon.json");
 var DAEMON_STATE_PATH = path7.join(OMNARA_HOME_DIR, "daemon-state.json");
 var DAEMON_LOG_DIR = path7.join(OMNARA_HOME_DIR, "logs", "daemon");
@@ -8886,6 +9081,16 @@ function extractErrorMessage11(error) {
 import chalk2 from "chalk";
 var exec = promisify(execCb);
 var DEFAULT_WAIT_MS = 1e4;
+function isDevelopmentMode4() {
+  if (process.env.OMNARA_ENV === "development") {
+    return true;
+  }
+  const backendUrl = process.env.OMNARA_BACKEND_URL;
+  if (backendUrl && (backendUrl.includes("localhost") || backendUrl.includes("127.0.0.1"))) {
+    return true;
+  }
+  return false;
+}
 async function ensureDaemonForSession(options = {}) {
   const logger2 = options.logger ?? logger;
   const client = new DaemonClient();
@@ -8992,28 +9197,47 @@ async function showDaemonStatus(options = {}) {
 }
 async function killAllDaemonProcesses(options = {}) {
   const logger2 = options.logger ?? logger;
+  const isDevMode = isDevelopmentMode4();
+  const envLabel = isDevMode ? "development" : "production";
+  logger2.info(`Killing ${envLabel} daemon processes...`);
+  const stateStore = new DaemonStateStore();
+  const targets = [];
   try {
-    const { stdout } = await exec("ps -axo pid=,command=");
-    const targets = [];
-    for (const line of stdout.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed) {
-        continue;
-      }
-      const [pidStr, ...cmdParts] = trimmed.split(/\s+/);
-      const pid = Number(pidStr);
-      if (!Number.isFinite(pid) || pid === process.pid) {
-        continue;
+    const state = await stateStore.load();
+    if (state && state.pid) {
+      try {
+        process.kill(state.pid, 0);
+        targets.push(state.pid);
+        logger2.debug(`Found ${envLabel} daemon PID from state file: ${state.pid}`);
+      } catch {
+        logger2.debug(`Daemon PID ${state.pid} from state file is not running`);
       }
-      const command = cmdParts.join(" ");
-      if (command.includes("omnara") && (command.includes("daemon run-service") || command.includes("daemon run-session"))) {
-        targets.push(pid);
+    }
+    try {
+      const { stdout } = await exec("ps -axo pid=,command=");
+      for (const line of stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+          continue;
+        }
+        const [pidStr, ...cmdParts] = trimmed.split(/\s+/);
+        const pid = Number(pidStr);
+        if (!Number.isFinite(pid) || pid === process.pid) {
+          continue;
+        }
+        const command = cmdParts.join(" ");
+        if (command.includes("omnara") && command.includes("daemon run-session") && !targets.includes(pid)) {
+          targets.push(pid);
+        }
       }
+    } catch (error) {
+      logger2.warn(`Failed to enumerate session processes: ${extractErrorMessage12(error)}`);
     }
     if (targets.length === 0) {
-      logger2.info("No omnara daemon processes found.");
+      logger2.info(`No ${envLabel} omnara daemon processes found.`);
       return;
     }
+    logger2.info(`Found ${targets.length} process(es) to kill in ${envLabel} mode`);
     for (const pid of targets) {
       try {
         process.kill(pid, "SIGKILL");
@@ -9022,8 +9246,10 @@ async function killAllDaemonProcesses(options = {}) {
         logger2.warn(`Failed to kill ${pid}: ${extractErrorMessage12(error)}`);
       }
     }
+    await stateStore.clear();
+    logger2.debug(`Cleared ${envLabel} daemon state file`);
   } catch (error) {
-    logger2.error(`Failed to enumerate processes: ${extractErrorMessage12(error)}`);
+    logger2.error(`Failed to kill ${envLabel} daemon processes: ${extractErrorMessage12(error)}`);
   }
 }
 async function registerDirectory(directoryPath, options) {
@@ -9634,7 +9860,7 @@ var FALLBACK_NAME = pkg.name ?? "omnara";
 var FALLBACK_VERSION = pkg.version ?? "0.0.0";
 var FALLBACK_DESCRIPTION = pkg.description ?? "Command-line interface for Omnara.";
 var PACKAGE_NAME = true ? "omnara" : FALLBACK_NAME;
-var PACKAGE_VERSION = true ? "0.2.0" : FALLBACK_VERSION;
+var PACKAGE_VERSION = true ? "0.2.2" : FALLBACK_VERSION;
 var PACKAGE_DESCRIPTION = true ? "Command-line interface for Omnara." : FALLBACK_DESCRIPTION;
 
 // src/daemon/machine-supervisor.ts
@@ -9779,9 +10005,7 @@ var MachineSupervisor = class {
       response = await registerMachine(this.apiClient, accessToken, payload);
     } catch (error) {
       if (error instanceof ApiError && error.status === 404 && config.machine?.id) {
-        this.logger.warn(
-          `Stored machine id ${config.machine.id} was not found. Re-registering.`
-        );
+        this.logger.warn(`Stored machine id ${config.machine.id} was not found. Re-registering.`);
         await this.configStore.update((current) => {
           current.machine = {
             name: machineName
@@ -10518,28 +10742,31 @@ async function performClaudeCodeCheck() {
     })) {
       if (message.type === "system") {
         if (message.subtype === "init") {
-          if (message.apiKeySource === "none") {
+          if (message.apiKeySource !== "none") {
             console.log(
-              chalk4.red(
-                "\nOmnara didn't detect a valid API key. Login via `claude login` or pass in a valid ANTHROPIC_API_KEY as an environment variable.\n"
-              )
-            );
-            return false;
-          } else {
-            console.log(chalk4.gray(`
+              chalk4.gray(`
 Omnara is using ${message.apiKeySource} for Claude Code access
-`));
+`)
+            );
+            return true;
           }
         }
       }
-      if (message.type === "auth_status") {
-        console.log(message);
+      if (message.type === "result" && message.subtype === "success") {
+        console.log(
+          chalk4.gray(`
+Omnara detected a Pro/Max subscription for Claude Code access
+`)
+        );
+        return true;
+      } else {
+        throw new Error("Failed to generate");
       }
     }
   } catch {
     console.log(
       chalk4.red(
-        "\nError: Omnara needs access to the Anthropic API. Omnara failed to query the Anthropic API, which means Claude Code likely isn't installed.\n"
+        "\nError: Omnara needs access to the Anthropic API. Omnara failed to query the Anthropic API, which means Claude Code likely isn't authenticated or installed. Try to log in using `claude /login`\n"
       )
     );
     return false;
@@ -10564,14 +10791,14 @@ function createProgram() {
 }
 async function run(argv) {
   const program = createProgram();
-  const authenticated = await performClaudeCodeCheck();
-  if (!authenticated) {
-    return;
-  }
   const reinstalled = await attemptUpdate();
   if (reinstalled) {
     return;
   }
+  const authenticated = await performClaudeCodeCheck();
+  if (!authenticated) {
+    return;
+  }
   try {
     await program.parseAsync(argv);
   } catch (error) {