omnara 0.3.1 → 0.3.2

package/dist/cli.js

@@ -6204,7 +6204,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.3.1" : FALLBACK_VERSION;
+var PACKAGE_VERSION = true ? "0.3.2" : FALLBACK_VERSION;
 var PACKAGE_DESCRIPTION = true ? "Command-line interface for Omnara." : FALLBACK_DESCRIPTION;
 
 // src/auth/supabase-client.ts
@@ -8041,8 +8041,8 @@ import * as Sentry26 from "@sentry/node";
 // src/daemon/daemon-launcher.ts
 import { spawn as spawn2, exec as execCb } from "node:child_process";
 import path12 from "node:path";
-import os3 from "node:os";
-import { promisify } from "node:util";
+import os4 from "node:os";
+import { promisify as promisify2 } from "node:util";
 
 // src/daemon/daemon-client.ts
 import http2 from "node:http";
@@ -8494,9 +8494,14 @@ import chalk2 from "chalk";
 // src/daemon/session-pid-registry.ts
 import fs10 from "node:fs/promises";
 import path11 from "node:path";
+import os3 from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import * as Sentry20 from "@sentry/node";
 var REGISTRY_PATH = path11.join(OMNARA_HOME_DIR, "session-processes.json");
 var LOCK_PATH = `${REGISTRY_PATH}.lock`;
+var execFileAsync = promisify(execFile);
+var START_TIME_TOLERANCE_MS = 5e3;
 async function acquireLock(retries = 20, delayMs = 50) {
   for (let attempt = 0; attempt < retries; attempt += 1) {
     try {
@@ -8519,7 +8524,24 @@ async function releaseLock(handle) {
 async function readRegistry() {
   try {
     const raw = await fs10.readFile(REGISTRY_PATH, "utf8");
-    return JSON.parse(raw);
+    const parsed = JSON.parse(raw);
+    const normalized = {};
+    for (const [sessionId, value] of Object.entries(parsed)) {
+      if (typeof value === "number") {
+        normalized[sessionId] = {
+          pid: value
+        };
+        continue;
+      }
+      if (value && typeof value.pid === "number") {
+        normalized[sessionId] = {
+          pid: value.pid,
+          startedAt: typeof value.startedAt === "string" ? value.startedAt : void 0,
+          command: typeof value.command === "string" ? value.command : void 0
+        };
+      }
+    }
+    return normalized;
   } catch (error) {
     if (error.code === "ENOENT") {
       return {};
@@ -8556,9 +8578,69 @@ async function isProcessAlive3(pid) {
     return true;
   }
 }
+async function isSessionProcessAlive(record) {
+  const alive = await isProcessAlive3(record.pid);
+  if (!alive) {
+    return false;
+  }
+  const tokensMatch = await matchesExpectedCommand(record.pid);
+  if (!tokensMatch) {
+    return false;
+  }
+  const timeMatch = await matchesStartTime(record.pid, record.startedAt);
+  if (record.startedAt && !timeMatch) {
+    return false;
+  }
+  return true;
+}
+async function matchesExpectedCommand(pid) {
+  if (os3.platform() === "win32") {
+    return true;
+  }
+  try {
+    const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "command="]);
+    const command = stdout.trim().toLowerCase();
+    if (!command) {
+      return false;
+    }
+    if (!command.includes("omnara") || !command.includes("daemon run-session")) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function matchesStartTime(pid, recordedStartedAt) {
+  if (os3.platform() === "win32") {
+    return true;
+  }
+  if (!recordedStartedAt) {
+    return true;
+  }
+  const recordedMs = Date.parse(recordedStartedAt);
+  if (Number.isNaN(recordedMs)) {
+    return true;
+  }
+  try {
+    const { stdout } = await execFileAsync("ps", ["-p", String(pid), "-o", "lstart="]);
+    const psStart = stdout.trim();
+    if (!psStart) {
+      return true;
+    }
+    const psDate = new Date(psStart);
+    if (Number.isNaN(psDate.getTime())) {
+      return true;
+    }
+    const delta = Math.abs(psDate.getTime() - recordedMs);
+    return delta <= START_TIME_TOLERANCE_MS;
+  } catch {
+    return true;
+  }
+}
 
 // src/daemon/daemon-launcher.ts
-var exec = promisify(execCb);
+var exec = promisify2(execCb);
 var DEFAULT_WAIT_MS = 1e4;
 async function ensureDaemonForSession(options = {}) {
   const logger3 = options.logger ?? logger;
@@ -8598,7 +8680,7 @@ async function ensureMachineNameConfigured(configStore, logger3) {
     process.env.OMNARA_MACHINE_NAME = config.machine.name;
     return config.machine.name;
   }
-  const defaultName = os3.hostname();
+  const defaultName = os4.hostname();
   let machineName = defaultName;
   if (process.stdin.isTTY && process.stdout.isTTY) {
     const answer = (await prompt(chalk2.blue(`Enter a name for this machine [${defaultName}]: `))).trim();
@@ -8732,20 +8814,19 @@ async function killSessionsByRegistry(options = {}) {
   const logger3 = options.logger ?? logger;
   try {
     await withSessionRegistry(async (registry) => {
-      const pids = Object.values(registry);
-      for (const pid of pids) {
-        if (!Number.isFinite(pid)) {
+      for (const record of Object.values(registry)) {
+        if (!record || !Number.isFinite(record.pid)) {
           continue;
         }
-        const alive = await isProcessAlive3(pid);
+        const alive = await isSessionProcessAlive(record);
         if (!alive) {
           continue;
         }
         try {
-          process.kill(pid, "SIGKILL");
-          logger3.success(`Killed session process ${pid}`);
+          process.kill(record.pid, "SIGKILL");
+          logger3.success(`Killed session process ${record.pid}`);
         } catch (error) {
-          logger3.warn(`Failed to kill session ${pid}: ${extractErrorMessage12(error)}`);
+          logger3.warn(`Failed to kill session ${record.pid}: ${extractErrorMessage12(error)}`);
         }
       }
       return [{}, void 0];
@@ -9051,7 +9132,7 @@ function extractErrorMessage13(error) {
 
 // src/daemon/machine-supervisor.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import os4 from "node:os";
+import os5 from "node:os";
 import { setTimeout as delay5 } from "node:timers/promises";
 import WebSocket2 from "ws";
 import * as Sentry23 from "@sentry/node";
@@ -9090,13 +9171,13 @@ async function ensureWorkspace(client, accessToken, payload) {
 // src/daemon/session-runner.ts
 import { spawn as spawn3 } from "node:child_process";
 import * as Sentry22 from "@sentry/node";
+import fs11 from "node:fs";
 import path13 from "node:path";
 var SessionManager = class {
   backendUrl;
   frontendUrl;
   directoryRegistry;
   logger;
-  runners = /* @__PURE__ */ new Map();
   constructor(options) {
     this.backendUrl = options.backendUrl;
     this.frontendUrl = options.frontendUrl;
@@ -9104,9 +9185,6 @@ var SessionManager = class {
     this.logger = options.logger;
   }
   async startSession(spec) {
-    if (this.runners.has(spec.launchId)) {
-      throw new Error("Session is already running on this machine");
-    }
     const entry = await this.directoryRegistry.getEntry(spec.directory);
     if (!entry) {
       throw new Error(`Directory ${spec.directory} is not registered on this machine`);
@@ -9118,23 +9196,15 @@ var SessionManager = class {
       frontendUrl: this.frontendUrl,
       logger: this.logger,
       onExit: () => {
-        this.runners.delete(spec.launchId);
       }
     });
-    this.runners.set(spec.launchId, runner);
     try {
       await runner.start();
     } catch (error) {
-      this.runners.delete(spec.launchId);
       Sentry22.captureException(error);
       throw error;
     }
   }
-  async stopAll() {
-    const runners = Array.from(this.runners.values());
-    this.runners.clear();
-    await Promise.all(runners.map((runner) => runner.stop()));
-  }
 };
 var SessionRunner = class {
   spec;
@@ -9143,12 +9213,7 @@ var SessionRunner = class {
   frontendUrl;
   logger;
   onExit;
-  startedAt = null;
   child = null;
-  exitPromise = null;
-  resolveExit = null;
-  exitHandled = false;
-  sessionLogPath = null;
   constructor(options) {
     this.spec = options.spec;
     this.directory = options.directory;
@@ -9165,15 +9230,12 @@ var SessionRunner = class {
     if (!entry) {
       throw new Error("Unable to determine CLI entry path for session runner");
     }
-    this.exitPromise = new Promise((resolve) => {
-      this.resolveExit = resolve;
-    });
-    this.sessionLogPath = await createSessionLogPath(this.spec.workspaceId, this.spec.launchId);
-    this.logger.info(`Session ${this.spec.launchId} logs available at ${this.sessionLogPath}`);
+    const sessionLogPath = await createSessionLogPath(this.spec.workspaceId, this.spec.launchId);
+    this.logger.info(`Session ${this.spec.launchId} logs available at ${sessionLogPath}`);
     await withSessionRegistry(async (registry) => {
-      const existingPid = registry[this.spec.userSessionId];
-      if (existingPid) {
-        const alive = await isProcessAlive3(existingPid);
+      const existing = registry[this.spec.userSessionId];
+      if (existing) {
+        const alive = await isSessionProcessAlive(existing);
         if (alive) {
           throw new Error(`User session ${this.spec.userSessionId} is already running`);
         }
@@ -9199,7 +9261,7 @@ var SessionRunner = class {
       OMNARA_WORKSPACE_ID: this.spec.workspaceId,
       OMNARA_WORKSPACE_DIR: this.directory.path,
       OMNARA_USER_SESSION_ID: this.spec.userSessionId,
-      ...this.sessionLogPath ? { OMNARA_SESSION_LOG_PATH: this.sessionLogPath } : {}
+      OMNARA_SESSION_LOG_PATH: sessionLogPath
     };
     if (this.spec.workspaceConfig) {
       env.OMNARA_WORKSPACE_CONFIG = JSON.stringify(this.spec.workspaceConfig);
@@ -9210,95 +9272,58 @@ var SessionRunner = class {
     if (this.spec.metadata) {
       env.OMNARA_WORKSPACE_METADATA = JSON.stringify(this.spec.metadata);
     }
-    const child = spawn3(process.execPath, args, {
-      cwd: this.directory.path,
-      stdio: ["ignore", "ignore", "ignore"],
-      env
-    });
-    this.child = child;
-    let spawned = false;
-    const spawnPromise = new Promise((resolve, reject) => {
-      child.once("spawn", () => {
-        spawned = true;
-        this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
-        this.writeLog("INFO", `Session process started in ${this.directory.path}`);
-        resolve();
+    let logFd = null;
+    try {
+      logFd = fs11.openSync(sessionLogPath, "a");
+      const child = spawn3(process.execPath, args, {
+        cwd: this.directory.path,
+        stdio: ["ignore", logFd, logFd],
+        env,
+        detached: true
       });
-      child.once("error", (error) => {
-        if (!spawned) {
-          Sentry22.captureException(error);
-          this.writeLog("ERROR", error.message);
-          this.cleanup();
-          this.resolveExit?.();
-          reject(error);
-        } else {
-          Sentry22.captureException(error);
-          this.handleExit(error.message, true);
-        }
+      fs11.closeSync(logFd);
+      logFd = null;
+      child.unref();
+      await new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
       });
-      child.once("exit", (code, signal) => {
-        const message = buildExitMessage(code, signal);
-        const failed = typeof code === "number" && code !== 0;
-        this.handleExit(message, failed);
+      this.child = child;
+      child.once("exit", () => {
+        this.onExit();
+        this.child = null;
       });
-    });
-    await withSessionRegistry(async (registry) => {
-      registry[this.spec.userSessionId] = child.pid ?? -1;
-      return [registry, null];
-    });
-    await spawnPromise;
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const command = `${process.execPath} ${args.join(" ")}`;
+      await withSessionRegistry(async (registry) => {
+        registry[this.spec.userSessionId] = {
+          pid: child.pid ?? -1,
+          startedAt,
+          command
+        };
+        return [registry, null];
+      });
+    } catch (error) {
+      if (logFd !== null) {
+        try {
+          fs11.closeSync(logFd);
+        } catch {
+        }
+      }
+      Sentry22.captureException(error);
+      this.logger.error("Failed to start session process:", error);
+      throw error;
+    }
   }
   async stop() {
     if (!this.child) {
-      await this.exitPromise;
       return;
     }
     if (!this.child.killed) {
       this.child.kill("SIGINT");
     }
-    await this.exitPromise;
-  }
-  handleExit(reason, failed) {
-    if (this.exitHandled) {
-      return;
-    }
-    this.exitHandled = true;
-    if (reason) {
-      this.writeLog(failed ? "ERROR" : "INFO", reason);
-    }
-    this.cleanup();
-    this.resolveExit?.();
-    this.onExit();
-  }
-  cleanup() {
-    if (this.child) {
-      this.child.removeAllListeners();
-      this.child = null;
-    }
-    void withSessionRegistry(async (registry) => {
-      delete registry[this.spec.userSessionId];
-      return [registry, null];
-    });
-  }
-  writeLog(level, ...args) {
-    if (level === "ERROR") {
-      this.logger.error(...args);
-    } else if (level === "WARN") {
-      this.logger.warn(...args);
-    } else {
-      this.logger.info(...args);
-    }
   }
 };
-function buildExitMessage(code, signal) {
-  if (code !== null) {
-    return code === 0 ? null : `Process exited with code ${code}`;
-  }
-  if (signal) {
-    return `Process terminated via signal ${signal}`;
-  }
-  return null;
-}
 async function createSessionLogPath(workspaceId, launchId) {
   await ensureOmnaraHome();
   const workspaceDir = path13.join(USER_SESSION_LOG_ROOT, workspaceId);
@@ -9312,6 +9337,7 @@ async function createSessionLogPath(workspaceId, launchId) {
 var HEARTBEAT_INTERVAL_MS = 1e4;
 var RECONNECT_DELAY_MS = 2e3;
 var LOGIN_WAIT_DELAY_MS2 = 3e4;
+var CONNECT_TIMEOUT_MS = 3e4;
 var DAEMON_VERSION = PACKAGE_VERSION ?? "0.0.0";
 var MachineSupervisor = class {
   backendUrl;
@@ -9376,15 +9402,14 @@ var MachineSupervisor = class {
       type: "heartbeat",
       status,
       metadata: {
-        hostname: os4.hostname(),
-        platform: os4.platform(),
-        architecture: os4.arch(),
+        hostname: os5.hostname(),
+        platform: os5.platform(),
+        architecture: os5.arch(),
         daemon_version: DAEMON_VERSION
       },
       directories: directories.map((entry) => entry.path)
     };
     await this.sendMessage(payload);
-    await this.sessionManager.stopAll();
     await this.closeWebsocket();
     if (this.loopPromise) {
       await this.loopPromise;
@@ -9435,9 +9460,9 @@ var MachineSupervisor = class {
     const payload = {
       machine_id: config.machine?.id,
       machine_name: machineName,
-      hostname: os4.hostname(),
-      platform: os4.platform(),
-      architecture: os4.arch(),
+      hostname: os5.hostname(),
+      platform: os5.platform(),
+      architecture: os5.arch(),
       daemon_version: DAEMON_VERSION,
       directories: directories.map((entry) => entry.path),
       metadata: {
@@ -9494,7 +9519,38 @@ var MachineSupervisor = class {
         }
       });
       this.websocket = ws;
+      let done = false;
+      let connectTimer = null;
+      const finish = (error) => {
+        if (done) return;
+        done = true;
+        if (connectTimer) {
+          clearTimeout(connectTimer);
+          connectTimer = null;
+        }
+        this.clearHeartbeatTimer();
+        this.websocket = null;
+        try {
+          ws.removeAllListeners();
+          if (ws.readyState === WebSocket2.OPEN || ws.readyState === WebSocket2.CONNECTING) {
+            ws.close();
+          }
+        } catch {
+        }
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      };
+      connectTimer = setTimeout(() => {
+        finish(new Error("machine websocket connection timed out"));
+      }, CONNECT_TIMEOUT_MS);
       ws.on("open", () => {
+        if (connectTimer) {
+          clearTimeout(connectTimer);
+          connectTimer = null;
+        }
         this.logger.success("\u2713 Machine daemon connected to backend");
         void this.sendHeartbeat().catch((error) => {
           this.logger.error("Failed to send heartbeat:", error);
@@ -9510,20 +9566,23 @@ var MachineSupervisor = class {
         }
       });
       ws.on("close", (code, reason) => {
+        if (connectTimer) {
+          clearTimeout(connectTimer);
+          connectTimer = null;
+        }
         this.logger.warn(
           `Machine websocket closed (${code}${reason ? `: ${reason.toString()}` : ""})`
         );
-        this.clearHeartbeatTimer();
-        this.websocket = null;
         if (this.stopRequested) {
-          resolve();
+          finish();
         } else {
-          reject(new Error("machine websocket closed"));
+          finish(new Error("machine websocket closed"));
         }
       });
       ws.on("error", (error) => {
         Sentry23.captureException(error);
         this.logger.error("Machine websocket error:", error);
+        finish(new Error("machine websocket error"));
       });
     });
   }
@@ -9711,9 +9770,9 @@ var MachineSupervisor = class {
       type: "heartbeat",
       status: "ONLINE",
       metadata: {
-        hostname: os4.hostname(),
-        platform: os4.platform(),
-        architecture: os4.arch(),
+        hostname: os5.hostname(),
+        platform: os5.platform(),
+        architecture: os5.arch(),
         daemon_version: DAEMON_VERSION
       },
       directories: directories.map((entry) => entry.path)
@@ -9782,7 +9841,7 @@ function isUnauthorizedApiError2(error) {
   return error instanceof ApiError && (error.status === 401 || error.status === 403);
 }
 function deriveMachineName() {
-  return process.env.OMNARA_MACHINE_NAME || os4.hostname();
+  return process.env.OMNARA_MACHINE_NAME || os5.hostname();
 }
 function decodeJson(raw) {
   const text = typeof raw === "string" ? raw : raw.toString("utf8");
@@ -9902,7 +9961,7 @@ var DaemonService = class {
 };
 
 // src/daemon/run-daemon.ts
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 import path14 from "node:path";
 async function runDaemonProcess() {
   await ensureOmnaraHome();
@@ -9910,7 +9969,7 @@ async function runDaemonProcess() {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const fileName = `${timestamp}-${process.pid}.log`;
   const logPath = path14.join(DAEMON_LOG_DIR, fileName);
-  const stream = fs11.createWriteStream(logPath, {
+  const stream = fs12.createWriteStream(logPath, {
     flags: "a",
     mode: DEFAULT_FILE_MODE2
   });