omnara 0.5.3 → 0.6.0

package/dist/cli.js

@@ -177,9 +177,11 @@ var BASE_ALLOWED_WORKER_TOOLS = [
   "Skill",
   "SlashCommand"
 ];
+var INTERRUPT_TIMEOUT_MS = 5e3;
 var AIClient = class {
   baseOptions;
   query;
+  abortController;
   currentModel = "sonnet";
   constructor(config) {
     const defaultOptions = {
@@ -202,17 +204,23 @@ var AIClient = class {
     this.ensureWorkingDirectory(this.baseOptions.cwd);
   }
   async *streamUserMessage(prompt2, overrides) {
+    this.abortController = new AbortController();
     const q = this.createQuery(prompt2, overrides);
     this.query = q;
-    for await (const message of q) {
-      yield message;
+    try {
+      for await (const message of q) {
+        yield message;
+      }
+    } finally {
+      this.query = void 0;
+      this.abortController = void 0;
     }
-    this.query = void 0;
   }
   createQuery(prompt2, overrides) {
     const merged = {
       ...this.baseOptions,
-      ...overrides
+      ...overrides,
+      abortController: this.abortController
     };
     this.ensureWorkingDirectory(merged.cwd);
     return query2({
@@ -221,10 +229,25 @@ var AIClient = class {
     });
   }
   async cancel() {
-    if (this.query) {
-      await this.query.interrupt();
-    } else {
-      console.warn("No query to interrupt. Ignoring");
+    if (!this.query) {
+      console.warn("[AIClient] No query to interrupt. Ignoring");
+      return;
+    }
+    try {
+      const interruptPromise = this.query.interrupt();
+      const timeoutPromise = new Promise(
+        (resolve) => setTimeout(() => resolve("timeout"), INTERRUPT_TIMEOUT_MS)
+      );
+      const result = await Promise.race([interruptPromise, timeoutPromise]);
+      if (result === "timeout") {
+        console.warn(
+          `[AIClient] interrupt() timed out after ${INTERRUPT_TIMEOUT_MS}ms, falling back to abort`
+        );
+        this.abortController?.abort();
+      }
+    } catch (error) {
+      console.warn("[AIClient] interrupt() failed, falling back to abort:", error);
+      this.abortController?.abort();
     }
   }
   isGenerating() {
@@ -602,8 +625,22 @@ function createEnvelope(sessionId, content, senderId, metadata, payloadMetadata)
 }
 function toMessageEnvelopes(message, sessionId) {
   const envelopes = [];
+  const messageAny = message;
+  const subagentSessionId = typeof messageAny.session_id === "string" ? messageAny.session_id : void 0;
+  const parentToolUseId = typeof messageAny.parent_tool_use_id === "string" ? messageAny.parent_tool_use_id : void 0;
+  const buildSubagentPayloadMetadata = () => {
+    const metadata = {};
+    if (parentToolUseId) {
+      metadata.parent_tool_use_id = parentToolUseId;
+    }
+    if (subagentSessionId && subagentSessionId !== sessionId) {
+      metadata.subagent_session_id = subagentSessionId;
+    }
+    return Object.keys(metadata).length > 0 ? metadata : void 0;
+  };
   switch (message.type) {
     case "assistant": {
+      const subagentMetadata = buildSubagentPayloadMetadata();
       for (const block of message.message.content) {
         if (isTextBlock(block)) {
           const content = {
@@ -611,9 +648,15 @@ function toMessageEnvelopes(message, sessionId) {
             text: block.text
           };
           envelopes.push(
-            createEnvelope(sessionId, content, sessionId, {
-              role: "assistant"
-            })
+            createEnvelope(
+              sessionId,
+              content,
+              sessionId,
+              {
+                role: "assistant"
+              },
+              subagentMetadata
+            )
           );
         } else if (isToolUseBlock(block)) {
           const content = {
@@ -623,15 +666,29 @@ function toMessageEnvelopes(message, sessionId) {
             arguments: normalizeToolArguments(block.input)
           };
           envelopes.push(
-            createEnvelope(sessionId, content, sessionId, {
-              role: "assistant"
-            })
+            createEnvelope(
+              sessionId,
+              content,
+              sessionId,
+              {
+                role: "assistant"
+              },
+              subagentMetadata
+            )
           );
         }
       }
       break;
     }
     case "user": {
+      if (parentToolUseId) {
+        break;
+      }
+      const firstBlock = message.message.content[0];
+      if (isTextBlock(firstBlock) && (firstBlock.text === "[Request interrupted by user]" || firstBlock.text === "[Request interrupted by user for tool use]")) {
+        break;
+      }
+      const subagentMetadata = buildSubagentPayloadMetadata();
       for (const block of message.message.content) {
         if (isToolResultBlock(block)) {
           const content = {
@@ -641,9 +698,15 @@ function toMessageEnvelopes(message, sessionId) {
             is_error: Boolean(block.is_error)
           };
           envelopes.push(
-            createEnvelope(sessionId, content, sessionId, {
-              role: "assistant"
-            })
+            createEnvelope(
+              sessionId,
+              content,
+              sessionId,
+              {
+                role: "assistant"
+              },
+              subagentMetadata
+            )
           );
         } else if (isTextBlock(block)) {
           const content = {
@@ -651,9 +714,15 @@ function toMessageEnvelopes(message, sessionId) {
             text: block.text
           };
           envelopes.push(
-            createEnvelope(sessionId, content, sessionId, {
-              role: "user"
-            })
+            createEnvelope(
+              sessionId,
+              content,
+              sessionId,
+              {
+                role: "user"
+              },
+              subagentMetadata
+            )
           );
         }
       }
@@ -666,6 +735,13 @@ function toMessageEnvelopes(message, sessionId) {
           type: "text",
           text: delta
         };
+        const streamPayloadMetadata = {
+          stream_delta: true
+        };
+        const subagentMeta = buildSubagentPayloadMetadata();
+        if (subagentMeta) {
+          Object.assign(streamPayloadMetadata, subagentMeta);
+        }
         envelopes.push(
           createEnvelope(
             sessionId,
@@ -674,9 +750,7 @@ function toMessageEnvelopes(message, sessionId) {
             {
               role: "assistant"
             },
-            {
-              stream_delta: true
-            }
+            streamPayloadMetadata
           )
         );
       }
@@ -783,6 +857,7 @@ var Session = class {
   sessionInitSubscribers = [];
   queue = [];
   generating = false;
+  waitingForMessage = null;
   announcementPromise = null;
   announced = false;
   shouldSummarize = false;
@@ -804,19 +879,29 @@ var Session = class {
       sessionId: this.id,
       queueLength: this.queue.length
     });
-    if (!this.generating && !this.ai.isGenerating()) {
+    if (this.waitingForMessage) {
+      const resolver = this.waitingForMessage;
+      this.waitingForMessage = null;
+      const batch = this.queue.splice(0, this.queue.length);
+      void this.emitProgress("running", "Generating response");
+      resolver(batch);
+    } else if (!this.generating && !this.ai.isGenerating()) {
       this.startGenerate();
     }
   }
   async *[Symbol.asyncIterator]() {
     while (true) {
-      if (this.queue.length === 0) {
-        logger.debug("[Session] Emptied queue", {
+      let batch;
+      if (this.queue.length > 0) {
+        batch = this.queue.splice(0, this.queue.length);
+      } else {
+        logger.debug("[Session] Iterator waiting for messages", {
           sessionId: this.id
         });
-        return;
+        batch = await new Promise((resolve) => {
+          this.waitingForMessage = resolve;
+        });
       }
-      const batch = this.queue.splice(0, this.queue.length);
       logger.debug("[Session] Yielding batch to SDK", {
         sessionId: this.id,
         batchSize: batch.length
@@ -849,28 +934,40 @@ var Session = class {
       const summaryTextBlocks = [];
       let resultMessage = null;
       await this.emitProgress("running", "Generating response");
-      for await (const message of this.ai.streamUserMessage(this, {
-        ...this.sdkSessionIdentifier ? { resume: this.sdkSessionIdentifier } : {}
-      })) {
-        this.captureSdkSessionId(message);
-        if (message.type === "assistant") {
-          this.collectAssistantSummaryBlocks(message, summaryTextBlocks);
-        }
-        if (message.type === "result") {
-          resultMessage = message;
+      try {
+        for await (const message of this.ai.streamUserMessage(this, {
+          ...this.sdkSessionIdentifier ? { resume: this.sdkSessionIdentifier } : {}
+        })) {
+          this.captureSdkSessionId(message);
+          if (message.type === "assistant") {
+            this.collectAssistantSummaryBlocks(message, summaryTextBlocks);
+          }
+          if (message.type === "result") {
+            resultMessage = message;
+            this.resetRetryState();
+            const complete = await this.buildCompletionEnvelope(resultMessage, summaryTextBlocks);
+            await Promise.all([
+              this.emitProgress("idle", "Ready for next message"),
+              this.dispatchEnvelope(complete)
+            ]);
+            summaryTextBlocks.length = 0;
+            resultMessage = null;
+          }
+          for (const envelope of toMessageEnvelopes(message, this.id)) {
+            await this.dispatchEnvelope(envelope);
+          }
         }
-        for (const envelope of toMessageEnvelopes(message, this.id)) {
-          await this.dispatchEnvelope(envelope);
+      } catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+          logger.info("[Session] Generation aborted", { sessionId: this.id });
+          await this.emitProgress("idle", "Generation cancelled");
+          return;
         }
+        throw error;
       }
-      this.resetRetryState();
-      const complete = await this.buildCompletionEnvelope(resultMessage, summaryTextBlocks);
-      await Promise.all([
-        this.emitProgress("idle", "Ready for next message"),
-        this.dispatchEnvelope(complete)
-      ]);
     } finally {
       this.generating = false;
+      this.waitingForMessage = null;
       logger.debug("[Session] Generation finished", {
         sessionId: this.id,
         pendingMessages: this.queue.length
@@ -2690,6 +2787,33 @@ var AgentOrchestrator = class {
           commit_sha: commitSha
         };
       }
+      if (req.action === "commit_checkout") {
+        try {
+          const currentBranch = await git.revparse(["--abbrev-ref", "HEAD"]);
+          const branchTrimmed = currentBranch.trim();
+          const repoPath = this.workerManager.repoPath;
+          const mainGit = simpleGit2(repoPath);
+          await mainGit.raw(["checkout", "-d", branchTrimmed]);
+          logger2.info(`[AgentOrchestrator] Checked out ${branchTrimmed} in main worktree`);
+          return {
+            type: "git_write",
+            success: true,
+            message: `Committed changes. The main workspace checked out the changes on this branch.`,
+            commit_sha: commitSha
+          };
+        } catch (checkoutError) {
+          logger2.error("[AgentOrchestrator] Failed to checkout in main worktree", {
+            error: checkoutError
+          });
+          return {
+            type: "git_write",
+            success: true,
+            message: `Committed successfully but failed to checkout in main worktree: ${checkoutError instanceof Error ? checkoutError.message : String(checkoutError)}`,
+            commit_sha: commitSha,
+            error: `Checkout failed: ${checkoutError instanceof Error ? checkoutError.message : String(checkoutError)}`
+          };
+        }
+      }
       return {
         type: "git_write",
         success: true,
@@ -3653,7 +3777,7 @@ var control_message_schema_default = {
     },
     GitWriteRequest: {
       additionalProperties: false,
-      description: 'Request to commit and optionally push changes.\n\nThe action field specifies what operation to perform:\n- "commit": Create a git commit with a generated message\n- "commit_push": Create a commit and push to origin\n- "commit_push_pr": Create a commit, push, and create a PR (not yet implemented)',
+      description: 'Request to commit and optionally push changes.\n\nThe action field specifies what operation to perform:\n- "commit": Create a git commit with a generated message\n- "commit_push": Create a commit and push to origin\n- "commit_push_pr": Create a commit, push, and create a PR (not yet implemented)\n- "commit_checkout": Create a commit and checkout the branch in the main worktree',
       properties: {
         type: {
           const: "git_write",
@@ -3665,7 +3789,8 @@ var control_message_schema_default = {
           enum: [
             "commit",
             "commit_push",
-            "commit_push_pr"
+            "commit_push_pr",
+            "commit_checkout"
           ],
           title: "Action",
           type: "string"
@@ -4747,12 +4872,23 @@ var machine_message_schema_default = {
           type: "string"
         },
         method: {
-          const: "start_session",
+          enum: [
+            "start_session",
+            "stop_session"
+          ],
           title: "Method",
           type: "string"
         },
         payload: {
-          $ref: "#/$defs/MachineStartSessionPayload"
+          anyOf: [
+            {
+              $ref: "#/$defs/MachineStartSessionPayload"
+            },
+            {
+              $ref: "#/$defs/MachineStopSessionPayload"
+            }
+          ],
+          title: "Payload"
         }
       },
       required: [
@@ -4926,6 +5062,22 @@ var machine_message_schema_default = {
       title: "MachineStatus",
       type: "string"
     },
+    MachineStopSessionPayload: {
+      additionalProperties: false,
+      description: "Payload instructing the daemon to terminate a running session.",
+      properties: {
+        user_session_id: {
+          format: "uuid",
+          title: "User Session Id",
+          type: "string"
+        }
+      },
+      required: [
+        "user_session_id"
+      ],
+      title: "MachineStopSessionPayload",
+      type: "object"
+    },
     WorkspaceConfig: {
       additionalProperties: false,
       description: "Workspace-level configuration persisted alongside metadata.",
@@ -9908,7 +10060,7 @@ function extractErrorMessage11(error) {
 // src/daemon/machine-supervisor.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
 import os5 from "node:os";
-import { setTimeout as delay4 } from "node:timers/promises";
+import { setTimeout as delay5 } from "node:timers/promises";
 import WebSocket3 from "ws";
 import * as Sentry21 from "@sentry/node";
 
@@ -17735,9 +17887,11 @@ async function ensureWorkspace(client, accessToken, payload) {
 
 // src/daemon/session-runner.ts
 import { spawn as spawn3 } from "node:child_process";
+import { setTimeout as delay4 } from "node:timers/promises";
 import * as Sentry20 from "@sentry/node";
 import fs11 from "node:fs";
 import path13 from "node:path";
+var GRACEFUL_STOP_DELAY_MS = 2e3;
 var SessionManager = class {
   backendUrl;
   frontendUrl;
@@ -17770,6 +17924,47 @@ var SessionManager = class {
       throw error;
     }
   }
+  /**
+   * Stop a running session by user session ID.
+   *
+   * Looks up the session in the PID registry, sends SIGTERM for graceful
+   * shutdown, waits briefly, then sends SIGKILL if still alive.
+   *
+   * @returns true if a running session was found and terminated, false if
+   *          the session was not running.
+   */
+  async stopSession(userSessionId) {
+    return await withSessionRegistry(async (registry) => {
+      const record = registry[userSessionId];
+      if (!record) {
+        return [registry, false];
+      }
+      const alive = await isSessionProcessAlive(record);
+      if (!alive) {
+        delete registry[userSessionId];
+        return [registry, false];
+      }
+      try {
+        process.kill(record.pid, "SIGTERM");
+        this.logger.debug(`Sent SIGTERM to session ${userSessionId} (pid ${record.pid})`);
+      } catch (error) {
+        this.logger.debug(`SIGTERM failed for pid ${record.pid}: ${String(error)}`);
+        delete registry[userSessionId];
+        return [registry, false];
+      }
+      await delay4(GRACEFUL_STOP_DELAY_MS);
+      const stillAlive = await isProcessAlive3(record.pid);
+      if (stillAlive) {
+        try {
+          process.kill(record.pid, "SIGKILL");
+          this.logger.debug(`Sent SIGKILL to session ${userSessionId} (pid ${record.pid})`);
+        } catch {
+        }
+      }
+      delete registry[userSessionId];
+      return [registry, true];
+    });
+  }
 };
 var SessionRunner = class {
   spec;
@@ -17900,7 +18095,7 @@ async function createSessionLogPath(workspaceId, launchId) {
 
 // src/package-info.ts
 var isBundled = true;
-var PACKAGE_VERSION = isBundled ? "0.5.3" : "0.0.0-dev";
+var PACKAGE_VERSION = isBundled ? "0.6.0" : "0.0.0-dev";
 var PACKAGE_DESCRIPTION = isBundled ? "Command-line interface for Omnara." : "Command-line interface for Omnara.";
 
 // src/daemon/machine-supervisor.ts
@@ -18009,13 +18204,13 @@ var MachineSupervisor = class {
           } else {
             this.logger.debug("Machine supervisor still waiting for login\u2026");
           }
-          await delay4(LOGIN_WAIT_DELAY_MS2);
+          await delay5(LOGIN_WAIT_DELAY_MS2);
         } else {
           Sentry21.captureException(error);
           this.logger.warn(
             `Machine supervisor error: ${error.message}. Retrying in ${Math.round(retryDelayMs / 1e3)}s.`
           );
-          await delay4(retryDelayMs);
+          await delay5(retryDelayMs);
           retryDelayMs = calculateBackoff(retryDelayMs);
         }
       }
@@ -18172,12 +18367,18 @@ var MachineSupervisor = class {
     }
   }
   async handleRpcRequest(message) {
-    if (message.method !== "start_session") {
+    if (message.method === "start_session") {
+      await this.handleStartSession(message);
+    } else if (message.method === "stop_session") {
+      await this.handleStopSession(message);
+    } else {
       await this.sendRpcResponse(message.request_id, "error", `Unknown method ${message.method}`);
-      return;
     }
+  }
+  async handleStartSession(message) {
     try {
-      const result = await this.launchWorkspaceSessionFromRpc(message.payload);
+      const payload = message.payload;
+      const result = await this.launchWorkspaceSessionFromRpc(payload);
       await this.sendRpcResponse(message.request_id, "ok", void 0, {
         launch_id: result.launchId,
         user_session_id: result.userSessionId,
@@ -18196,6 +18397,25 @@ var MachineSupervisor = class {
       await this.sendRpcResponse(message.request_id, "error", messageText);
     }
   }
+  async handleStopSession(message) {
+    const payload = message.payload;
+    const userSessionId = payload.user_session_id;
+    try {
+      const stopped = await this.sessionManager.stopSession(userSessionId);
+      if (stopped) {
+        this.logger.info(`Stopped session ${userSessionId}`);
+        await this.sendRpcResponse(message.request_id, "ok");
+      } else {
+        this.logger.debug(`Session ${userSessionId} was not running`);
+        await this.sendRpcResponse(message.request_id, "not_found", "Session not running");
+      }
+    } catch (error) {
+      Sentry21.captureException(error);
+      const messageText = error instanceof Error ? error.message : String(error);
+      this.logger.warn(`Failed to stop session ${userSessionId}: ${messageText}`);
+      await this.sendRpcResponse(message.request_id, "error", messageText);
+    }
+  }
   async sendRpcResponse(requestId, status, error, body) {
     const response = {
       type: "rpc_response",
@@ -18317,7 +18537,7 @@ var MachineSupervisor = class {
           return;
         }
       }
-      await delay4(250);
+      await delay5(250);
     }
     throw new Error("Machine has not finished registering yet. Try again in a few seconds.");
   }
@@ -18606,6 +18826,44 @@ function compareVersions(v1, v2) {
   }
   return 0;
 }
+function isNpmInstallation() {
+  if (isBunSingleFileExecutable()) {
+    return false;
+  }
+  const execPath = process.argv[1] ?? "";
+  if (execPath.includes("node_modules")) {
+    return true;
+  }
+  if (execPath.includes("/lib/node_modules/") || execPath.includes("\\node_modules\\")) {
+    return true;
+  }
+  try {
+    const realPath = realpathSync(execPath);
+    if (realPath.includes("node_modules")) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function uninstallNpmVersion() {
+  console.log(chalk4.blue("Uninstalling npm version of Omnara..."));
+  try {
+    execSync2("npm uninstall -g omnara", { stdio: "inherit" });
+    return true;
+  } catch {
+    try {
+      if (platform() !== "win32") {
+        execSync2("sudo npm uninstall -g omnara", { stdio: "inherit" });
+        return true;
+      }
+    } catch {
+    }
+  }
+  console.log(chalk4.yellow("Could not automatically uninstall npm version."));
+  console.log(chalk4.yellow("Please run manually: npm uninstall -g omnara"));
+  return false;
+}
 async function runInstallScript(options) {
   const os6 = platform();
   const silent = options?.silent ?? false;
@@ -18649,6 +18907,38 @@ async function runInstallScript(options) {
     return false;
   }
 }
+async function handleNpmInstallation() {
+  const os6 = platform();
+  const installCmd = os6 === "win32" ? `irm ${INSTALL_SCRIPT_URL_WINDOWS} | iex` : `curl -fsSL ${INSTALL_SCRIPT_URL_UNIX} | bash`;
+  const border = chalk4.yellow("=".repeat(60));
+  console.log("\n" + border);
+  console.log(chalk4.yellow.bold("  npm Installation Detected"));
+  console.log(border);
+  console.log(
+    chalk4.white(`
+  Omnara CLI is now distributed as a standalone executable
+  with automatic updates and improved performance.
+
+  Migrating to the new installation method...
+`)
+  );
+  uninstallNpmVersion();
+  const success = await runInstallScript();
+  if (success) {
+    console.log(chalk4.green("\nMigration complete!"));
+    console.log(chalk4.white("Please restart your terminal and run `omnara` again.\n"));
+    return true;
+  } else {
+    console.log(
+      chalk4.yellow(`
+To complete migration manually, run:
+
+  ${chalk4.cyan(installCmd)}
+`)
+    );
+    return false;
+  }
+}
 async function checkForUpdate() {
   const currentVersion = PACKAGE_VERSION;
   if (!currentVersion) {
@@ -18704,6 +18994,9 @@ async function attemptUpdate() {
     if (!currentVersion) {
       return false;
     }
+    if (isNpmInstallation()) {
+      return await handleNpmInstallation();
+    }
     const updateInfo = await checkForUpdate();
     if (!updateInfo.available) {
       const channel = IS_PRERELEASE ? " (prerelease channel)" : "";