@zonease/happy 0.6.38 → 0.6.39

package/dist/run-BDn2aE3Q.cjs

@@ -0,0 +1,2152 @@
+'use strict';
+
+var fs$1 = require('fs/promises');
+var os = require('os');
+var tmp = require('tmp');
+var api = require('./api-CwOCQeLH.cjs');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var auth = require('./auth-BIleVCw0.cjs');
+var child_process = require('child_process');
+var doctor = require('./doctor-Cya9YSA0.cjs');
+var spawnHappyCLI = require('./spawnHappyCLI-D_V-AAoP.cjs');
+var controlClient = require('./controlClient-DZMIsKsT.cjs');
+var install = require('./install-BokHRgFW.cjs');
+var fastify = require('fastify');
+var fs = require('node:fs');
+var promises = require('node:fs/promises');
+var path = require('node:path');
+var z = require('zod');
+var fastifyTypeProviderZod = require('fastify-type-provider-zod');
+var fs$2 = require('fs');
+var path$1 = require('path');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var common = require('./common-CZvSRU4p.cjs');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var tmp__namespace = /*#__PURE__*/_interopNamespaceDefault(tmp);
+
+let caffeinateProcess = null;
+function startCaffeinate() {
+  if (logger.configuration.disableCaffeinate) {
+    logger.logger.debug("[caffeinate] Caffeinate disabled via HAPPY_DISABLE_CAFFEINATE environment variable");
+    return false;
+  }
+  if (process.platform !== "darwin") {
+    logger.logger.debug("[caffeinate] Not on macOS, skipping caffeinate");
+    return false;
+  }
+  if (caffeinateProcess && !caffeinateProcess.killed) {
+    logger.logger.debug("[caffeinate] Caffeinate already running");
+    return true;
+  }
+  try {
+    caffeinateProcess = child_process.spawn("caffeinate", ["-im"], {
+      stdio: "ignore",
+      detached: false
+    });
+    caffeinateProcess.on("error", (error) => {
+      logger.logger.debug("[caffeinate] Error starting caffeinate:", error);
+      caffeinateProcess = null;
+    });
+    caffeinateProcess.on("exit", (code, signal) => {
+      logger.logger.debug(`[caffeinate] Process exited with code ${code}, signal ${signal}`);
+      caffeinateProcess = null;
+    });
+    logger.logger.debug(`[caffeinate] Started with PID ${caffeinateProcess.pid}`);
+    setupCleanupHandlers();
+    return true;
+  } catch (error) {
+    logger.logger.debug("[caffeinate] Failed to start caffeinate:", error);
+    return false;
+  }
+}
+let isStopping = false;
+async function stopCaffeinate() {
+  if (isStopping) {
+    logger.logger.debug("[caffeinate] Already stopping, skipping");
+    return;
+  }
+  if (caffeinateProcess && !caffeinateProcess.killed) {
+    isStopping = true;
+    logger.logger.debug(`[caffeinate] Stopping caffeinate process PID ${caffeinateProcess.pid}`);
+    try {
+      caffeinateProcess.kill("SIGTERM");
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      if (caffeinateProcess && !caffeinateProcess.killed) {
+        logger.logger.debug("[caffeinate] Force killing caffeinate process");
+        caffeinateProcess.kill("SIGKILL");
+      }
+      caffeinateProcess = null;
+      isStopping = false;
+    } catch (error) {
+      logger.logger.debug("[caffeinate] Error stopping caffeinate:", error);
+      isStopping = false;
+    }
+  }
+}
+let cleanupHandlersSet = false;
+function setupCleanupHandlers() {
+  if (cleanupHandlersSet) {
+    return;
+  }
+  cleanupHandlersSet = true;
+  const cleanup = () => {
+    stopCaffeinate();
+  };
+  process.on("exit", cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  process.on("SIGUSR1", cleanup);
+  process.on("SIGUSR2", cleanup);
+  process.on("uncaughtException", (error) => {
+    logger.logger.debug("[caffeinate] Uncaught exception, cleaning up:", error);
+    cleanup();
+  });
+  process.on("unhandledRejection", (reason, promise) => {
+    logger.logger.debug("[caffeinate] Unhandled rejection, cleaning up:", reason);
+    cleanup();
+  });
+}
+
+const VIDEO_CONTENT_TYPES = {
+  ".webm": "video/webm",
+  ".mp4": "video/mp4",
+  ".m4v": "video/mp4",
+  ".mov": "video/quicktime",
+  ".ogv": "video/ogg"
+};
+function getFileStreamContentType(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  return VIDEO_CONTENT_TYPES[extension] ?? "application/octet-stream";
+}
+function getFileStreamCorsHeaders() {
+  return {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "Range, Access-Control-Request-Private-Network",
+    "Access-Control-Expose-Headers": "Accept-Ranges, Content-Length, Content-Range, Content-Type",
+    "Access-Control-Allow-Private-Network": "true"
+  };
+}
+function parseFileStreamRange(rangeHeader, size) {
+  if (!Number.isSafeInteger(size) || size <= 0) {
+    return { ok: false };
+  }
+  if (!rangeHeader) {
+    return { ok: true, partial: false, start: 0, end: size - 1 };
+  }
+  const match = /^bytes=(\d*)-(\d*)$/.exec(rangeHeader.trim());
+  if (!match) {
+    return { ok: false };
+  }
+  const [, rawStart, rawEnd] = match;
+  if (!rawStart && !rawEnd) {
+    return { ok: false };
+  }
+  let start;
+  let end;
+  if (!rawStart) {
+    const suffixLength = Number.parseInt(rawEnd, 10);
+    if (!Number.isSafeInteger(suffixLength) || suffixLength <= 0) {
+      return { ok: false };
+    }
+    start = Math.max(size - suffixLength, 0);
+    end = size - 1;
+  } else {
+    start = Number.parseInt(rawStart, 10);
+    end = rawEnd ? Number.parseInt(rawEnd, 10) : size - 1;
+  }
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start || start >= size) {
+    return { ok: false };
+  }
+  return { ok: true, partial: true, start, end: Math.min(end, size - 1) };
+}
+
+function startDaemonControlServer({
+  getChildren,
+  stopSession,
+  spawnSession,
+  requestShutdown,
+  onHappySessionWebhook
+}) {
+  return new Promise((resolve) => {
+    const app = fastify({
+      logger: false
+      // We use our own logger
+    });
+    app.setValidatorCompiler(fastifyTypeProviderZod.validatorCompiler);
+    app.setSerializerCompiler(fastifyTypeProviderZod.serializerCompiler);
+    const typed = app.withTypeProvider();
+    const addFileStreamCorsHeaders = (reply) => {
+      for (const [key, value] of Object.entries(getFileStreamCorsHeaders())) {
+        reply.header(key, value);
+      }
+    };
+    typed.options("/file-stream", async (_request, reply) => {
+      addFileStreamCorsHeaders(reply);
+      reply.header("Access-Control-Allow-Methods", "GET, OPTIONS");
+      reply.code(204);
+      return "";
+    });
+    typed.get("/file-stream", {
+      schema: {
+        querystring: z.z.object({
+          path: z.z.string().min(1)
+        })
+      }
+    }, async (request, reply) => {
+      addFileStreamCorsHeaders(reply);
+      const filePath = request.query.path;
+      if (!path.isAbsolute(filePath)) {
+        reply.code(400);
+        return { error: "path must be absolute" };
+      }
+      let stats;
+      try {
+        stats = await promises.stat(filePath);
+      } catch (error) {
+        logger.logger.debug(`[CONTROL SERVER] File stream stat failed for ${filePath}:`, error);
+        reply.code(404);
+        return { error: "file not found" };
+      }
+      if (!stats.isFile()) {
+        reply.code(400);
+        return { error: "path is not a file" };
+      }
+      const range = parseFileStreamRange(request.headers.range, stats.size);
+      if (!range.ok) {
+        reply.code(416);
+        reply.header("Content-Range", `bytes */${stats.size}`);
+        return { error: "range not satisfiable" };
+      }
+      const contentLength = range.end - range.start + 1;
+      reply.code(range.partial ? 206 : 200);
+      reply.header("Content-Type", getFileStreamContentType(filePath));
+      reply.header("Accept-Ranges", "bytes");
+      reply.header("Content-Length", String(contentLength));
+      reply.header("Cache-Control", "no-store");
+      reply.header("Content-Disposition", `inline; filename="${path.basename(filePath).replace(/["\\]/g, "_")}"`);
+      if (range.partial) {
+        reply.header("Content-Range", `bytes ${range.start}-${range.end}/${stats.size}`);
+      }
+      return reply.send(fs.createReadStream(filePath, { start: range.start, end: range.end }));
+    });
+    typed.post("/session-started", {
+      schema: {
+        body: z.z.object({
+          sessionId: z.z.string(),
+          metadata: z.z.any()
+          // Metadata type from API
+        }),
+        response: {
+          200: z.z.object({
+            status: z.z.literal("ok")
+          })
+        }
+      }
+    }, async (request) => {
+      const { sessionId, metadata } = request.body;
+      logger.logger.debug(`[CONTROL SERVER] Session started: ${sessionId}`);
+      onHappySessionWebhook(sessionId, metadata);
+      return { status: "ok" };
+    });
+    typed.post("/list", {
+      schema: {
+        response: {
+          200: z.z.object({
+            children: z.z.array(z.z.object({
+              startedBy: z.z.string(),
+              happySessionId: z.z.string(),
+              pid: z.z.number()
+            }))
+          })
+        }
+      }
+    }, async () => {
+      const children = getChildren();
+      logger.logger.debug(`[CONTROL SERVER] Listing ${children.length} sessions`);
+      return {
+        children: children.filter((child) => child.happySessionId !== void 0).map((child) => ({
+          startedBy: child.startedBy,
+          happySessionId: child.happySessionId,
+          pid: child.pid
+        }))
+      };
+    });
+    typed.post("/stop-session", {
+      schema: {
+        body: z.z.object({
+          sessionId: z.z.string()
+        }),
+        response: {
+          200: z.z.object({
+            success: z.z.boolean()
+          })
+        }
+      }
+    }, async (request) => {
+      const { sessionId } = request.body;
+      logger.logger.debug(`[CONTROL SERVER] Stop session request: ${sessionId}`);
+      const success = stopSession(sessionId);
+      return { success };
+    });
+    typed.post("/spawn-session", {
+      schema: {
+        body: z.z.object({
+          directory: z.z.string(),
+          sessionId: z.z.string().optional()
+        }),
+        response: {
+          200: z.z.object({
+            success: z.z.boolean(),
+            sessionId: z.z.string().optional(),
+            approvedNewDirectoryCreation: z.z.boolean().optional()
+          }),
+          409: z.z.object({
+            success: z.z.boolean(),
+            requiresUserApproval: z.z.boolean().optional(),
+            actionRequired: z.z.string().optional(),
+            directory: z.z.string().optional()
+          }),
+          500: z.z.object({
+            success: z.z.boolean(),
+            error: z.z.string().optional()
+          })
+        }
+      }
+    }, async (request, reply) => {
+      const { directory, sessionId } = request.body;
+      logger.logger.debug(`[CONTROL SERVER] Spawn session request: dir=${directory}, sessionId=${sessionId || "new"}`);
+      const result = await spawnSession({ directory, sessionId });
+      switch (result.type) {
+        case "success":
+          if (!result.sessionId) {
+            reply.code(500);
+            return {
+              success: false,
+              error: "Failed to spawn session: no session ID returned"
+            };
+          }
+          return {
+            success: true,
+            sessionId: result.sessionId,
+            approvedNewDirectoryCreation: true
+          };
+        case "requestToApproveDirectoryCreation":
+          reply.code(409);
+          return {
+            success: false,
+            requiresUserApproval: true,
+            actionRequired: "CREATE_DIRECTORY",
+            directory: result.directory
+          };
+        case "error":
+          reply.code(500);
+          return {
+            success: false,
+            error: result.errorMessage
+          };
+      }
+    });
+    typed.post("/stop", {
+      schema: {
+        response: {
+          200: z.z.object({
+            status: z.z.string()
+          })
+        }
+      }
+    }, async () => {
+      logger.logger.debug("[CONTROL SERVER] Stop daemon request received");
+      setTimeout(() => {
+        logger.logger.debug("[CONTROL SERVER] Triggering daemon shutdown");
+        requestShutdown();
+      }, 50);
+      return { status: "stopping" };
+    });
+    app.listen({ port: 0, host: "127.0.0.1" }, (err, address) => {
+      if (err) {
+        logger.logger.debug("[CONTROL SERVER] Failed to start:", err);
+        throw err;
+      }
+      const port = parseInt(address.split(":").pop());
+      logger.logger.debug(`[CONTROL SERVER] Started on port ${port}`);
+      resolve({
+        port,
+        stop: async () => {
+          logger.logger.debug("[CONTROL SERVER] Stopping server");
+          await app.close();
+          logger.logger.debug("[CONTROL SERVER] Server stopped");
+        }
+      });
+    });
+  });
+}
+
+class TmuxSessionIdentifierError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TmuxSessionIdentifierError";
+  }
+}
+function parseTmuxSessionIdentifier(identifier) {
+  if (!identifier || typeof identifier !== "string") {
+    throw new TmuxSessionIdentifierError("Session identifier must be a non-empty string");
+  }
+  const parts = identifier.split(":");
+  if (parts.length === 0 || !parts[0]) {
+    throw new TmuxSessionIdentifierError("Invalid session identifier: missing session name");
+  }
+  const result = {
+    session: parts[0].trim()
+  };
+  if (!/^[a-zA-Z0-9._-]+$/.test(result.session)) {
+    throw new TmuxSessionIdentifierError(`Invalid session name: "${result.session}". Only alphanumeric characters, dots, hyphens, and underscores are allowed.`);
+  }
+  if (parts.length > 1) {
+    const windowAndPane = parts[1].split(".");
+    result.window = windowAndPane[0]?.trim();
+    if (result.window && !/^[a-zA-Z0-9._-]+$/.test(result.window)) {
+      throw new TmuxSessionIdentifierError(`Invalid window name: "${result.window}". Only alphanumeric characters, dots, hyphens, and underscores are allowed.`);
+    }
+    if (windowAndPane.length > 1) {
+      result.pane = windowAndPane[1]?.trim();
+      if (result.pane && !/^[0-9]+$/.test(result.pane)) {
+        throw new TmuxSessionIdentifierError(`Invalid pane identifier: "${result.pane}". Only numeric values are allowed.`);
+      }
+    }
+  }
+  return result;
+}
+function formatTmuxSessionIdentifier(identifier) {
+  if (!identifier.session) {
+    throw new TmuxSessionIdentifierError("Session identifier must have a session name");
+  }
+  let result = identifier.session;
+  if (identifier.window) {
+    result += `:${identifier.window}`;
+    if (identifier.pane) {
+      result += `.${identifier.pane}`;
+    }
+  }
+  return result;
+}
+const WIN_OPS = {
+  // Navigation and window management
+  "new-window": "new-window",
+  "new": "new-window",
+  "nw": "new-window",
+  "select-window": "select-window -t",
+  "sw": "select-window -t",
+  "window": "select-window -t",
+  "w": "select-window -t",
+  "next-window": "next-window",
+  "n": "next-window",
+  "prev-window": "previous-window",
+  "p": "previous-window",
+  "pw": "previous-window",
+  // Pane management
+  "split-window": "split-window",
+  "split": "split-window",
+  "sp": "split-window",
+  "vsplit": "split-window -h",
+  "vsp": "split-window -h",
+  "select-pane": "select-pane -t",
+  "pane": "select-pane -t",
+  "next-pane": "select-pane -t :.+",
+  "np": "select-pane -t :.+",
+  "prev-pane": "select-pane -t :.-",
+  "pp": "select-pane -t :.-",
+  // Session management
+  "new-session": "new-session",
+  "ns": "new-session",
+  "new-sess": "new-session",
+  "attach-session": "attach-session -t",
+  "attach": "attach-session -t",
+  "as": "attach-session -t",
+  "detach-client": "detach-client",
+  "detach": "detach-client",
+  "dc": "detach-client",
+  // Layout and display
+  "select-layout": "select-layout",
+  "layout": "select-layout",
+  "sl": "select-layout",
+  "clock-mode": "clock-mode",
+  "clock": "clock-mode",
+  // Copy mode
+  "copy-mode": "copy-mode",
+  "copy": "copy-mode",
+  // Search and navigation in copy mode
+  "search-forward": "search-forward",
+  "search-backward": "search-backward",
+  // Misc operations
+  "list-windows": "list-windows",
+  "lw": "list-windows",
+  "list-sessions": "list-sessions",
+  "ls": "list-sessions",
+  "list-panes": "list-panes",
+  "lp": "list-panes",
+  "rename-window": "rename-window",
+  "rename": "rename-window",
+  "kill-window": "kill-window",
+  "kw": "kill-window",
+  "kill-pane": "kill-pane",
+  "kp": "kill-pane",
+  "kill-session": "kill-session",
+  "ks": "kill-session",
+  // Display and info
+  "display-message": "display-message",
+  "display": "display-message",
+  "dm": "display-message",
+  "show-options": "show-options",
+  "show": "show-options",
+  "so": "show-options",
+  // Control and scripting
+  "send-keys": "send-keys",
+  "send": "send-keys",
+  "sk": "send-keys",
+  "capture-pane": "capture-pane",
+  "capture": "capture-pane",
+  "cp": "capture-pane",
+  "pipe-pane": "pipe-pane",
+  "pipe": "pipe-pane",
+  // Buffer operations
+  "list-buffers": "list-buffers",
+  "lb": "list-buffers",
+  "save-buffer": "save-buffer",
+  "sb": "save-buffer",
+  "delete-buffer": "delete-buffer",
+  "db": "delete-buffer",
+  // Advanced operations
+  "resize-pane": "resize-pane",
+  "resize": "resize-pane",
+  "rp": "resize-pane",
+  "swap-pane": "swap-pane",
+  "swap": "swap-pane",
+  "join-pane": "join-pane",
+  "join": "join-pane",
+  "break-pane": "break-pane",
+  "break": "break-pane"
+};
+const COMMANDS_SUPPORTING_TARGET = /* @__PURE__ */ new Set([
+  "send-keys",
+  "capture-pane",
+  "new-window",
+  "kill-window",
+  "select-window",
+  "split-window",
+  "select-pane",
+  "kill-pane",
+  "select-layout",
+  "display-message",
+  "attach-session",
+  "detach-client",
+  "new-session",
+  "kill-session",
+  "list-windows",
+  "list-panes"
+]);
+const CONTROL_SEQUENCES = /* @__PURE__ */ new Set([
+  "C-m",
+  "C-c",
+  "C-l",
+  "C-u",
+  "C-w",
+  "C-a",
+  "C-b",
+  "C-d",
+  "C-e",
+  "C-f",
+  "C-g",
+  "C-h",
+  "C-i",
+  "C-j",
+  "C-k",
+  "C-n",
+  "C-o",
+  "C-p",
+  "C-q",
+  "C-r",
+  "C-s",
+  "C-t",
+  "C-v",
+  "C-x",
+  "C-y",
+  "C-z",
+  "C-\\",
+  "C-]",
+  "C-[",
+  "C-]"
+]);
+class TmuxUtilities {
+  /** Default session name to prevent interference */
+  static DEFAULT_SESSION_NAME = "happy";
+  controlState = "normal" /* NORMAL */;
+  sessionName;
+  constructor(sessionName) {
+    this.sessionName = sessionName || TmuxUtilities.DEFAULT_SESSION_NAME;
+  }
+  /**
+   * Detect tmux environment from TMUX environment variable
+   */
+  detectTmuxEnvironment() {
+    const tmuxEnv = process.env.TMUX;
+    if (!tmuxEnv) {
+      return null;
+    }
+    try {
+      const parts = tmuxEnv.split(",");
+      if (parts.length >= 3) {
+        const socketPath = parts[0];
+        const pathParts = parts[1].split("/");
+        const sessionAndWindow = pathParts[pathParts.length - 1] || parts[1];
+        const pane = parts[2];
+        let session;
+        let window;
+        if (sessionAndWindow.includes(".")) {
+          const parts2 = sessionAndWindow.split(".", 2);
+          session = parts2[0];
+          window = parts2[1] || "0";
+        } else {
+          session = sessionAndWindow;
+          window = "0";
+        }
+        return {
+          session,
+          window,
+          pane,
+          socket_path: socketPath
+        };
+      }
+    } catch (error) {
+      logger.logger.debug("[TMUX] Failed to parse TMUX environment variable:", error);
+    }
+    return null;
+  }
+  /**
+   * Execute tmux command with proper session targeting and socket handling
+   */
+  async executeTmuxCommand(cmd, session, window, pane, socketPath) {
+    const targetSession = session || this.sessionName;
+    let baseCmd = ["tmux"];
+    if (socketPath) {
+      baseCmd = ["tmux", "-S", socketPath];
+    }
+    if (cmd.length > 0 && cmd[0] === "send-keys") {
+      const fullCmd = [...baseCmd, cmd[0]];
+      let target = targetSession;
+      if (window) target += `:${window}`;
+      if (pane) target += `.${pane}`;
+      fullCmd.push("-t", target);
+      fullCmd.push(...cmd.slice(1));
+      return this.executeCommand(fullCmd);
+    } else {
+      const fullCmd = [...baseCmd, ...cmd];
+      if (cmd.length > 0 && COMMANDS_SUPPORTING_TARGET.has(cmd[0])) {
+        let target = targetSession;
+        if (window) target += `:${window}`;
+        if (pane) target += `.${pane}`;
+        fullCmd.push("-t", target);
+      }
+      return this.executeCommand(fullCmd);
+    }
+  }
+  /**
+   * Execute command with subprocess and return result
+   */
+  async executeCommand(cmd) {
+    try {
+      const result = await this.runCommand(cmd);
+      return {
+        returncode: result.exitCode,
+        stdout: result.stdout || "",
+        stderr: result.stderr || "",
+        command: cmd
+      };
+    } catch (error) {
+      logger.logger.debug("[TMUX] Command execution failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Run command using Node.js child_process.spawn
+   */
+  runCommand(args, options = {}) {
+    return new Promise((resolve, reject) => {
+      const child = child_process.spawn(args[0], args.slice(1), {
+        stdio: ["ignore", "pipe", "pipe"],
+        timeout: 5e3,
+        shell: false,
+        ...options
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      child.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      child.on("close", (code) => {
+        resolve({
+          exitCode: code || 0,
+          stdout,
+          stderr
+        });
+      });
+      child.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Parse control sequences in text (^ for escape, ^^ for literal ^)
+   */
+  parseControlSequences(text) {
+    const result = [];
+    let i = 0;
+    let localState = this.controlState;
+    while (i < text.length) {
+      const char = text[i];
+      if (localState === "normal" /* NORMAL */) {
+        if (char === "^") {
+          if (i + 1 < text.length && text[i + 1] === "^") {
+            result.push("^");
+            i += 2;
+          } else {
+            localState = "escape" /* ESCAPE */;
+            i += 1;
+          }
+        } else {
+          result.push(char);
+          i += 1;
+        }
+      } else if (localState === "escape" /* ESCAPE */) {
+        result.push(char);
+        i += 1;
+        localState = "normal" /* NORMAL */;
+      } else {
+        result.push(char);
+        i += 1;
+      }
+    }
+    this.controlState = localState;
+    return [result.join(""), localState];
+  }
+  /**
+   * Execute window operation using WIN_OPS dispatch with type safety
+   */
+  async executeWinOp(operation, args = [], session, window, pane) {
+    const tmuxCmd = WIN_OPS[operation];
+    if (!tmuxCmd) {
+      logger.logger.debug(`[TMUX] Unknown operation: ${operation}`);
+      return false;
+    }
+    const cmdParts = tmuxCmd.split(" ");
+    cmdParts.push(...args);
+    const result = await this.executeTmuxCommand(cmdParts, session, window, pane);
+    return result !== null && result.returncode === 0;
+  }
+  /**
+   * Ensure session exists, create if needed
+   */
+  async ensureSessionExists(sessionName) {
+    const targetSession = sessionName || this.sessionName;
+    const result = await this.executeTmuxCommand(["has-session", "-t", targetSession]);
+    if (result && result.returncode === 0) {
+      return true;
+    }
+    const createResult = await this.executeTmuxCommand(["new-session", "-d", "-s", targetSession]);
+    return createResult !== null && createResult.returncode === 0;
+  }
+  /**
+   * Capture current input from tmux pane
+   */
+  async captureCurrentInput(session, window, pane) {
+    const result = await this.executeTmuxCommand(["capture-pane", "-p"], session, window, pane);
+    if (result && result.returncode === 0) {
+      const lines = result.stdout.trim().split("\n");
+      return lines[lines.length - 1] || "";
+    }
+    return "";
+  }
+  /**
+   * Check if user is actively typing
+   */
+  async isUserTyping(checkInterval = 500, maxChecks = 3, session, window, pane) {
+    const initialInput = await this.captureCurrentInput(session, window, pane);
+    for (let i = 0; i < maxChecks - 1; i++) {
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      const currentInput = await this.captureCurrentInput(session, window, pane);
+      if (currentInput !== initialInput) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Send keys to tmux pane with proper control sequence handling and type safety
+   */
+  async sendKeys(keys, session, window, pane) {
+    if (!keys || typeof keys !== "string") {
+      logger.logger.debug("[TMUX] Invalid keys provided to sendKeys");
+      return false;
+    }
+    if (CONTROL_SEQUENCES.has(keys)) {
+      const result = await this.executeTmuxCommand(["send-keys", keys], session, window, pane);
+      return result !== null && result.returncode === 0;
+    } else {
+      const result = await this.executeTmuxCommand(["send-keys", keys], session, window, pane);
+      return result !== null && result.returncode === 0;
+    }
+  }
+  /**
+   * Send multiple keys to tmux pane with proper control sequence handling
+   */
+  async sendMultipleKeys(keys, session, window, pane) {
+    if (!Array.isArray(keys) || keys.length === 0) {
+      logger.logger.debug("[TMUX] Invalid keys array provided to sendMultipleKeys");
+      return false;
+    }
+    for (const key of keys) {
+      const success = await this.sendKeys(key, session, window, pane);
+      if (!success) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Get comprehensive session information
+   */
+  async getSessionInfo(sessionName) {
+    const targetSession = sessionName || this.sessionName;
+    const envInfo = this.detectTmuxEnvironment();
+    const info = {
+      target_session: targetSession,
+      session: targetSession,
+      window: "unknown",
+      pane: "unknown",
+      socket_path: void 0,
+      tmux_active: envInfo !== null,
+      current_session: envInfo?.session,
+      available_sessions: []
+    };
+    if (envInfo && envInfo.session === targetSession) {
+      info.window = envInfo.window;
+      info.pane = envInfo.pane;
+      info.socket_path = envInfo.socket_path;
+    } else if (envInfo) {
+      info.env_session = envInfo.session;
+      info.env_window = envInfo.window;
+      info.env_pane = envInfo.pane;
+    }
+    const result = await this.executeTmuxCommand(["list-sessions"]);
+    if (result && result.returncode === 0) {
+      info.available_sessions = result.stdout.trim().split("\n").filter((line) => line.trim()).map((line) => line.split(":")[0]);
+    }
+    return info;
+  }
+  /**
+   * Spawn process in tmux session with environment variables.
+   *
+   * IMPORTANT: Unlike Node.js spawn(), env is a separate parameter.
+   * This is intentional because:
+   * - Tmux windows inherit environment from the tmux server
+   * - Only NEW or DIFFERENT variables need to be set via -e flag
+   * - Passing all of process.env would create 50+ unnecessary -e flags
+   *
+   * @param args - Command and arguments to execute (as array, will be joined)
+   * @param options - Spawn options (tmux-specific, excludes env)
+   * @param env - Environment variables to set in window (only pass what's different!)
+   * @returns Result with success status and session identifier
+   */
+  async spawnInTmux(args, options = {}, env) {
+    try {
+      const tmuxCheck = await this.executeTmuxCommand(["list-sessions"]);
+      if (!tmuxCheck) {
+        throw new Error("tmux not available");
+      }
+      let sessionName = options.sessionName !== void 0 && options.sessionName !== "" ? options.sessionName : null;
+      if (!sessionName) {
+        const listResult = await this.executeTmuxCommand(["list-sessions", "-F", "#{session_name}"]);
+        if (listResult && listResult.returncode === 0 && listResult.stdout.trim()) {
+          const firstSession = listResult.stdout.trim().split("\n")[0];
+          sessionName = firstSession;
+          logger.logger.debug(`[TMUX] Using first existing session: ${sessionName}`);
+        } else {
+          sessionName = "happy";
+          logger.logger.debug(`[TMUX] No existing sessions, using default: ${sessionName}`);
+        }
+      }
+      const windowName = options.windowName || `happy-${Date.now()}`;
+      await this.ensureSessionExists(sessionName);
+      const fullCommand = args.join(" ");
+      const createWindowArgs = ["new-window", "-n", windowName];
+      if (options.cwd) {
+        const cwdPath = typeof options.cwd === "string" ? options.cwd : options.cwd.pathname;
+        createWindowArgs.push("-c", cwdPath);
+      }
+      if (env && Object.keys(env).length > 0) {
+        for (const [key, value] of Object.entries(env)) {
+          if (value === void 0 || value === null) {
+            logger.logger.warn(`[TMUX] Skipping undefined/null environment variable: ${key}`);
+            continue;
+          }
+          if (!/^[A-Z_][A-Z0-9_]*$/i.test(key)) {
+            logger.logger.warn(`[TMUX] Skipping invalid environment variable name: ${key}`);
+            continue;
+          }
+          createWindowArgs.push("-e", `${key}=${value}`);
+        }
+        logger.logger.debug(`[TMUX] Setting ${Object.keys(env).length} environment variables in tmux window`);
+      }
+      createWindowArgs.push(fullCommand);
+      createWindowArgs.push("-P");
+      createWindowArgs.push("-F", "#{pane_pid}");
+      const createResult = await this.executeTmuxCommand(createWindowArgs, sessionName);
+      if (!createResult || createResult.returncode !== 0) {
+        throw new Error(`Failed to create tmux window: ${createResult?.stderr}`);
+      }
+      const panePid = parseInt(createResult.stdout.trim());
+      if (isNaN(panePid)) {
+        throw new Error(`Failed to extract PID from tmux output: ${createResult.stdout}`);
+      }
+      logger.logger.debug(`[TMUX] Spawned command in tmux session ${sessionName}, window ${windowName}, PID ${panePid}`);
+      const sessionIdentifier = {
+        session: sessionName,
+        window: windowName
+      };
+      return {
+        success: true,
+        sessionId: formatTmuxSessionIdentifier(sessionIdentifier),
+        pid: panePid
+      };
+    } catch (error) {
+      logger.logger.debug("[TMUX] Failed to spawn in tmux:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Get session info for a given session identifier string
+   */
+  async getSessionInfoFromString(sessionIdentifier) {
+    try {
+      const parsed = parseTmuxSessionIdentifier(sessionIdentifier);
+      const info = await this.getSessionInfo(parsed.session);
+      return info;
+    } catch (error) {
+      if (error instanceof TmuxSessionIdentifierError) {
+        logger.logger.debug(`[TMUX] Invalid session identifier: ${error.message}`);
+      } else {
+        logger.logger.debug("[TMUX] Error getting session info:", error);
+      }
+      return null;
+    }
+  }
+  /**
+   * Kill a tmux window safely with proper error handling
+   */
+  async killWindow(sessionIdentifier) {
+    try {
+      const parsed = parseTmuxSessionIdentifier(sessionIdentifier);
+      if (!parsed.window) {
+        throw new TmuxSessionIdentifierError(`Window identifier required: ${sessionIdentifier}`);
+      }
+      const result = await this.executeWinOp("kill-window", [parsed.window], parsed.session);
+      return result;
+    } catch (error) {
+      if (error instanceof TmuxSessionIdentifierError) {
+        logger.logger.debug(`[TMUX] Invalid window identifier: ${error.message}`);
+      } else {
+        logger.logger.debug("[TMUX] Error killing window:", error);
+      }
+      return false;
+    }
+  }
+  /**
+   * List windows in a session
+   */
+  async listWindows(sessionName) {
+    const targetSession = sessionName || this.sessionName;
+    const result = await this.executeTmuxCommand(["list-windows", "-t", targetSession]);
+    if (!result || result.returncode !== 0) {
+      return [];
+    }
+    const windows = [];
+    const lines = result.stdout.trim().split("\n");
+    for (const line of lines) {
+      const match = line.match(/^\d+:\s+(\w+)/);
+      if (match) {
+        windows.push(match[1]);
+      }
+    }
+    return windows;
+  }
+}
+let _tmuxUtils = null;
+function getTmuxUtilities(sessionName) {
+  if (!_tmuxUtils || sessionName && sessionName !== _tmuxUtils.sessionName) {
+    _tmuxUtils = new TmuxUtilities(sessionName);
+  }
+  return _tmuxUtils;
+}
+async function isTmuxAvailable() {
+  try {
+    const utils = new TmuxUtilities();
+    const result = await utils.executeTmuxCommand(["list-sessions"]);
+    return result !== null;
+  } catch {
+    return false;
+  }
+}
+
+function expandEnvironmentVariables(envVars, sourceEnv = process.env) {
+  const expanded = {};
+  const undefinedVars = [];
+  for (const [key, value] of Object.entries(envVars)) {
+    const expandedValue = value.replace(/\$\{([^}]+)\}/g, (match, expr) => {
+      const colonDashIndex = expr.indexOf(":-");
+      let varName;
+      let defaultValue;
+      if (colonDashIndex !== -1) {
+        varName = expr.substring(0, colonDashIndex);
+        defaultValue = expr.substring(colonDashIndex + 2);
+      } else {
+        varName = expr;
+      }
+      const resolvedValue = sourceEnv[varName];
+      if (resolvedValue !== void 0) {
+        const isSensitive = varName.toLowerCase().includes("token") || varName.toLowerCase().includes("key") || varName.toLowerCase().includes("secret");
+        const displayValue = isSensitive ? resolvedValue ? `<${resolvedValue.length} chars>` : "<empty>" : resolvedValue;
+        logger.logger.debug(`[EXPAND ENV] Expanded ${varName} from daemon env: ${displayValue}`);
+        if (resolvedValue === "") {
+          logger.logger.warn(`[EXPAND ENV] WARNING: ${varName} is set but EMPTY in daemon environment`);
+        }
+        return resolvedValue;
+      } else if (defaultValue !== void 0) {
+        logger.logger.debug(`[EXPAND ENV] Using default value for ${varName}: ${defaultValue}`);
+        return defaultValue;
+      } else {
+        undefinedVars.push(varName);
+        return match;
+      }
+    });
+    expanded[key] = expandedValue;
+  }
+  if (undefinedVars.length > 0) {
+    logger.logger.warn(`[EXPAND ENV] Undefined variables referenced in profile environment: ${undefinedVars.join(", ")}`);
+    logger.logger.warn(`[EXPAND ENV] Session may fail to authenticate. Set these in daemon environment before launching:`);
+    undefinedVars.forEach((varName) => {
+      logger.logger.warn(`[EXPAND ENV]   ${varName}=<your-value>`);
+    });
+  }
+  return expanded;
+}
+
+const GEMINI_TEXT_KEYS = /* @__PURE__ */ new Set([
+  "text",
+  "content",
+  "output",
+  "message",
+  "response",
+  "result",
+  "answer",
+  "final_text"
+]);
+const GEMINI_META_KEYS = /* @__PURE__ */ new Set([
+  "session_id",
+  "sessionId",
+  "id",
+  "usage",
+  "metadata",
+  "model",
+  "role",
+  "timestamp"
+]);
+const ANSI_ESCAPE_REGEX = /\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+function stripAnsi(value) {
+  return value.replace(ANSI_ESCAPE_REGEX, "");
+}
+function extractCodexSessionId(output) {
+  const cleaned = stripAnsi(output);
+  const match = cleaned.match(/session id:\s*([^\s]+)/i);
+  if (!match) {
+    return null;
+  }
+  const token = match[1].trim().replace(/^['"`(\[]+|[)\]"'`,.;:]+$/g, "");
+  if (!/^[0-9a-zA-Z-]{8,}$/.test(token)) {
+    return null;
+  }
+  return token;
+}
+function extractGeminiSessionId(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.session_id === "string") {
+      const sessionId = parsed.session_id.trim();
+      if (sessionId.length > 0) {
+        return sessionId;
+      }
+    }
+  } catch (_error) {
+  }
+  for (const line of stdout.split(/\r?\n/)) {
+    const result = extractGeminiSessionIdFromJsonLine(line);
+    if (result) {
+      return result;
+    }
+  }
+  return null;
+}
+function extractGeminiSessionIdFromJsonLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.session_id === "string") {
+      const sessionId = parsed.session_id.trim();
+      return sessionId.length > 0 ? sessionId : null;
+    }
+  } catch (_error) {
+    return null;
+  }
+  return null;
+}
+function collectGeminiTextCandidates(value, out) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length > 0) {
+      out.push(trimmed);
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectGeminiTextCandidates(item, out);
+    }
+    return;
+  }
+  if (!value || typeof value !== "object") {
+    return;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    if (GEMINI_META_KEYS.has(key)) {
+      continue;
+    }
+    if (GEMINI_TEXT_KEYS.has(key)) {
+      collectGeminiTextCandidates(child, out);
+      continue;
+    }
+    if (key === "parts" && Array.isArray(child)) {
+      collectGeminiTextCandidates(child, out);
+      continue;
+    }
+    collectGeminiTextCandidates(child, out);
+  }
+}
+function normalizeGeminiOutputText(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return "";
+  }
+  const candidates = [];
+  let sawJson = false;
+  try {
+    const parsed = JSON.parse(trimmed);
+    sawJson = true;
+    collectGeminiTextCandidates(parsed, candidates);
+  } catch (_error) {
+  }
+  if (!sawJson) {
+    for (const line of stdout.split(/\r?\n/)) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine) continue;
+      try {
+        const parsed = JSON.parse(trimmedLine);
+        sawJson = true;
+        collectGeminiTextCandidates(parsed, candidates);
+      } catch (_error) {
+      }
+    }
+  }
+  if (!sawJson) {
+    return trimmed;
+  }
+  const unique = [...new Set(candidates)];
+  return unique.join("\n").trim();
+}
+
+const SESSION_SCOPED_HAPPY_ENV_KEYS = [
+  "HAPPY_CLAUDE_RESUME_SESSION_ID",
+  "HAPPY_CLAUDE_BACKFILL",
+  "HAPPY_CLAUDE_BACKFILL_MAX_MESSAGES",
+  "HAPPY_CLAUDE_BACKFILL_MAX_USER_MESSAGES",
+  "HAPPY_CLAUDE_BACKFILL_MAX_BYTES",
+  "HAPPY_CLAUDE_SKIP_FORK_SESSION",
+  "HAPPY_GEMINI_RESUME_SESSION_ID",
+  "HAPPY_GEMINI_BACKFILL",
+  "HAPPY_CODEX_RESUME_FILE",
+  "HAPPY_CODEX_BACKFILL",
+  "HAPPY_SESSION_TITLE",
+  "HAPPY_WORKTREE_BASE_PATH",
+  "HAPPY_WORKTREE_BRANCH_NAME",
+  "HAPPY_WORKSPACE_REPOS",
+  "HAPPY_WORKSPACE_PATH",
+  "HAPPY_EXTRA_MCP_SERVERS"
+];
+function stripSessionScopedHappyEnv(env) {
+  const cleaned = { ...env };
+  for (const key of SESSION_SCOPED_HAPPY_ENV_KEYS) {
+    delete cleaned[key];
+  }
+  return cleaned;
+}
+const ORCHESTRATOR_WATCHDOG_GRACE_MS = 5e3;
+const ORCHESTRATOR_OUTPUT_CAPTURE_LIMIT = 64e3;
+const ORCHESTRATOR_SHUTDOWN_WAIT_MS = 8e3;
+const initialMachineMetadata = {
+  host: os.hostname(),
+  platform: os.platform(),
+  happyCliVersion: logger.packageJson.version,
+  homeDir: os.homedir(),
+  happyHomeDir: logger.configuration.happyHomeDir,
+  happyLibDir: projectPath.projectPath()
+};
+async function buildMachineMetadata() {
+  const settings = await logger.readSettings();
+  return { ...initialMachineMetadata, deviceMode: settings.deviceMode === true };
+}
+async function getProfileEnvironmentVariablesForAgent(profileId, agentType) {
+  try {
+    const settings = await logger.readSettings();
+    const profile = settings.profiles.find((p) => p.id === profileId);
+    if (!profile) {
+      logger.logger.debug(`[DAEMON RUN] Profile ${profileId} not found`);
+      return {};
+    }
+    if (!logger.validateProfileForAgent(profile, agentType)) {
+      logger.logger.debug(`[DAEMON RUN] Profile ${profileId} not compatible with agent ${agentType}`);
+      return {};
+    }
+    const envVars = logger.getProfileEnvironmentVariables(profile);
+    logger.logger.debug(`[DAEMON RUN] Loaded ${Object.keys(envVars).length} environment variables from profile ${profileId} for agent ${agentType}`);
+    return envVars;
+  } catch (error) {
+    logger.logger.debug("[DAEMON RUN] Failed to get profile environment variables:", error);
+    return {};
+  }
+}
+async function startDaemon() {
+  for (const key of SESSION_SCOPED_HAPPY_ENV_KEYS) {
+    if (process.env[key] !== void 0) {
+      logger.logger.debug(`[DAEMON RUN] Stripping leaked session-scoped env on entry: ${key}`);
+      delete process.env[key];
+    }
+  }
+  let requestShutdown;
+  let resolvesWhenShutdownRequested = new Promise((resolve) => {
+    requestShutdown = (source, errorMessage) => {
+      logger.logger.debug(`[DAEMON RUN] Requesting shutdown (source: ${source}, errorMessage: ${errorMessage})`);
+      setTimeout(async () => {
+        logger.logger.debug("[DAEMON RUN] Startup malfunctioned, forcing exit with code 1");
+        await new Promise((resolve2) => setTimeout(resolve2, 100));
+        process.exit(1);
+      }, 1e3);
+      resolve({ source, errorMessage });
+    };
+  });
+  process.on("SIGINT", () => {
+    logger.logger.debug("[DAEMON RUN] Received SIGINT");
+    requestShutdown("os-signal");
+  });
+  process.on("SIGTERM", () => {
+    logger.logger.debug("[DAEMON RUN] Received SIGTERM");
+    requestShutdown("os-signal");
+  });
+  process.on("uncaughtException", (error) => {
+    logger.logger.debug("[DAEMON RUN] FATAL: Uncaught exception", error);
+    logger.logger.debug(`[DAEMON RUN] Stack trace: ${error.stack}`);
+    requestShutdown("exception", error.message);
+  });
+  process.on("unhandledRejection", (reason, promise) => {
+    logger.logger.debug("[DAEMON RUN] FATAL: Unhandled promise rejection", reason);
+    logger.logger.debug(`[DAEMON RUN] Rejected promise:`, promise);
+    const error = reason instanceof Error ? reason : new Error(`Unhandled promise rejection: ${reason}`);
+    logger.logger.debug(`[DAEMON RUN] Stack trace: ${error.stack}`);
+    requestShutdown("exception", error.message);
+  });
+  process.on("exit", (code) => {
+    logger.logger.debug(`[DAEMON RUN] Process exiting with code: ${code}`);
+  });
+  process.on("beforeExit", (code) => {
+    logger.logger.debug(`[DAEMON RUN] Process about to exit with code: ${code}`);
+  });
+  logger.logger.debug("[DAEMON RUN] Starting daemon process...");
+  logger.logger.debugLargeJson("[DAEMON RUN] Environment", doctor.getEnvironmentInfo());
+  const runningDaemonVersionMatches = await controlClient.isDaemonRunningCurrentlyInstalledHappyVersion();
+  if (!runningDaemonVersionMatches) {
+    logger.logger.debug("[DAEMON RUN] Daemon version mismatch detected, restarting daemon with current CLI version");
+    await controlClient.stopDaemon();
+  } else {
+    logger.logger.debug("[DAEMON RUN] Daemon version matches, keeping existing daemon");
+    console.log("Daemon already running with matching version");
+    process.exit(0);
+  }
+  const daemonLockHandle = await logger.acquireDaemonLock(5, 200);
+  if (!daemonLockHandle) {
+    logger.logger.debug("[DAEMON RUN] Daemon lock file already held, another daemon is running");
+    process.exit(0);
+  }
+  try {
+    const caffeinateStarted = startCaffeinate();
+    if (caffeinateStarted) {
+      logger.logger.debug("[DAEMON RUN] Sleep prevention enabled");
+    }
+    const { credentials, machineId } = await auth.authAndSetupMachineIfNeeded();
+    logger.logger.debug("[DAEMON RUN] Auth and machine setup complete");
+    let api$1;
+    const pidToTrackedSession = /* @__PURE__ */ new Map();
+    const pidToAwaiter = /* @__PURE__ */ new Map();
+    const getCurrentChildren = () => Array.from(pidToTrackedSession.values());
+    const executionIdToManagedExecution = /* @__PURE__ */ new Map();
+    const clearExecutionTimers = (execution) => {
+      if (execution.watchdogTimer) {
+        clearTimeout(execution.watchdogTimer);
+        execution.watchdogTimer = null;
+      }
+      if (execution.killTimer) {
+        clearTimeout(execution.killTimer);
+        execution.killTimer = null;
+      }
+    };
+    const requestExecutionTermination = (execution) => {
+      if (execution.child.killed) {
+        return;
+      }
+      try {
+        execution.child.kill("SIGTERM");
+      } catch (error) {
+        logger.logger.debug(`[ORCHESTRATOR] Failed to send SIGTERM for execution ${execution.payload.executionId}`, error);
+      }
+      if (execution.killTimer) {
+        return;
+      }
+      execution.killTimer = setTimeout(() => {
+        execution.killTimer = null;
+        if (execution.child.exitCode !== null || execution.child.signalCode !== null) {
+          return;
+        }
+        try {
+          execution.child.kill("SIGKILL");
+        } catch (error) {
+          logger.logger.debug(`[ORCHESTRATOR] Failed to send SIGKILL for execution ${execution.payload.executionId}`, error);
+        }
+      }, ORCHESTRATOR_WATCHDOG_GRACE_MS);
+    };
+    const reportExecutionFinish = async (execution, opts) => {
+      if (execution.finishReportPromise) {
+        await execution.finishReportPromise;
+        return;
+      }
+      execution.finishReportPromise = (async () => {
+        const normalizedStdout = execution.payload.provider === "gemini" ? normalizeGeminiOutputText(execution.stdout) : execution.stdout.trim();
+        const outputText = [normalizedStdout, execution.stderr.trim()].filter(Boolean).join("\n");
+        const outputSummary = common.buildOutputSummary(normalizedStdout, execution.stderr);
+        const normalizedChildSessionId = execution.detectedChildSessionId?.trim();
+        try {
+          await api$1.reportOrchestratorExecutionFinish({
+            executionId: execution.payload.executionId,
+            dispatchToken: execution.payload.dispatchToken,
+            status: opts.status,
+            finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            exitCode: opts.exitCode,
+            signal: opts.signal,
+            outputSummary: outputSummary ?? void 0,
+            outputText: outputText || void 0,
+            childSessionId: normalizedChildSessionId ? normalizedChildSessionId : void 0,
+            errorCode: opts.errorCode,
+            errorMessage: opts.errorMessage
+          });
+        } catch (error) {
+          logger.logger.debug(`[ORCHESTRATOR] Failed to report finish for execution ${execution.payload.executionId}`, error);
+        } finally {
+          clearExecutionTimers(execution);
+          executionIdToManagedExecution.delete(execution.payload.executionId);
+        }
+      })();
+      await execution.finishReportPromise;
+    };
+    const finalizeExecution = async (executionId, exitCode, signal) => {
+      const execution = executionIdToManagedExecution.get(executionId);
+      if (!execution) {
+        return;
+      }
+      if (!execution.detectedChildSessionId && execution.payload.provider === "gemini" && execution.payload.executionType === "initial") {
+        const parsed = extractGeminiSessionId(execution.stdout);
+        if (parsed) {
+          execution.detectedChildSessionId = parsed;
+        }
+      }
+      const status = common.mapFinishStatus({
+        watchdogTriggered: execution.watchdogTriggered,
+        cancelRequested: execution.cancelRequested,
+        exitCode
+      });
+      await execution.startReportPromise;
+      await reportExecutionFinish(execution, {
+        status,
+        exitCode,
+        signal,
+        errorCode: status === "timeout" ? "WATCHDOG_TIMEOUT" : status === "failed" ? "PROCESS_EXIT_NON_ZERO" : void 0,
+        errorMessage: status === "timeout" ? `Execution exceeded timeout (${execution.payload.timeoutMs}ms)` : status === "failed" ? `Process exited with code ${exitCode ?? "unknown"}${signal ? ` (signal ${signal})` : ""}` : void 0
+      });
+    };
+    const handleOrchestratorDispatch = async (payload) => {
+      const existing = executionIdToManagedExecution.get(payload.executionId);
+      if (existing) {
+        if (existing.payload.dispatchToken !== payload.dispatchToken) {
+          throw new Error(`Execution ${payload.executionId} already running with different dispatchToken`);
+        }
+        return { accepted: true, duplicate: true };
+      }
+      const oneshotEnv = common.buildOrchestratorEnv(payload);
+      const child = spawnHappyCLI.spawnHappyCLI(["orchestrator-oneshot", "--provider", payload.provider], {
+        cwd: os.homedir(),
+        detached: false,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+          ...stripSessionScopedHappyEnv(process.env),
+          ...oneshotEnv
+        }
+      });
+      const execution = {
+        payload,
+        child,
+        startedAtIso: (/* @__PURE__ */ new Date()).toISOString(),
+        cancelRequested: false,
+        watchdogTriggered: false,
+        detectedChildSessionId: payload.childSessionId ?? null,
+        startReportPromise: Promise.resolve(),
+        finishReportPromise: null,
+        stdout: "",
+        stderr: "",
+        stdoutLineBuffer: "",
+        watchdogTimer: null,
+        killTimer: null
+      };
+      execution.startReportPromise = api$1.reportOrchestratorExecutionStart({
+        executionId: payload.executionId,
+        dispatchToken: payload.dispatchToken,
+        startedAt: execution.startedAtIso,
+        pid: child.pid
+      }).catch((error) => {
+        logger.logger.debug(`[ORCHESTRATOR] Failed to report start for execution ${payload.executionId}`, error);
+      });
+      executionIdToManagedExecution.set(payload.executionId, execution);
+      child.stdout?.on("data", (chunk) => {
+        const text = chunk.toString();
+        execution.stdout = common.appendOutputChunk(execution.stdout, text, ORCHESTRATOR_OUTPUT_CAPTURE_LIMIT);
+        if (!execution.detectedChildSessionId) {
+          if (payload.provider === "codex" && payload.executionType === "initial") {
+            const probe = `${execution.stdoutLineBuffer}${text}`;
+            const parsed = extractCodexSessionId(probe);
+            if (parsed) {
+              execution.detectedChildSessionId = parsed;
+            }
+            execution.stdoutLineBuffer = probe.slice(-256);
+          } else if (payload.provider === "gemini" && payload.executionType === "initial") {
+            execution.stdoutLineBuffer += text;
+            const lines = execution.stdoutLineBuffer.split(/\r?\n/);
+            execution.stdoutLineBuffer = lines.pop() ?? "";
+            for (const line of lines) {
+              const parsed = extractGeminiSessionIdFromJsonLine(line);
+              if (parsed) {
+                execution.detectedChildSessionId = parsed;
+                break;
+              }
+            }
+          }
+        }
+      });
+      child.stderr?.on("data", (chunk) => {
+        const text = chunk.toString();
+        execution.stderr = common.appendOutputChunk(execution.stderr, text, ORCHESTRATOR_OUTPUT_CAPTURE_LIMIT);
+        if (!execution.detectedChildSessionId && payload.provider === "codex" && payload.executionType === "initial") {
+          const probe = `${execution.stdoutLineBuffer}${text}`;
+          const parsed = extractCodexSessionId(probe);
+          if (parsed) {
+            execution.detectedChildSessionId = parsed;
+          }
+          execution.stdoutLineBuffer = probe.slice(-256);
+        }
+      });
+      child.once("error", async (error) => {
+        execution.stderr = common.appendOutputChunk(execution.stderr, `
+${error.message}
+`, ORCHESTRATOR_OUTPUT_CAPTURE_LIMIT);
+        await execution.startReportPromise;
+        await reportExecutionFinish(execution, {
+          status: execution.watchdogTriggered ? "timeout" : execution.cancelRequested ? "cancelled" : "failed",
+          exitCode: execution.child.exitCode,
+          signal: execution.child.signalCode,
+          errorCode: "SPAWN_ERROR",
+          errorMessage: error.message
+        });
+      });
+      child.once("exit", async (code, signal) => {
+        await finalizeExecution(payload.executionId, code, signal);
+      });
+      execution.watchdogTimer = setTimeout(() => {
+        execution.watchdogTimer = null;
+        execution.watchdogTriggered = true;
+        requestExecutionTermination(execution);
+      }, payload.timeoutMs);
+      return { accepted: true };
+    };
+    const handleOrchestratorCancel = async (payload) => {
+      const execution = executionIdToManagedExecution.get(payload.executionId);
+      if (!execution) {
+        return { accepted: true, notFound: true };
+      }
+      if (execution.payload.dispatchToken !== payload.dispatchToken) {
+        throw new Error(`dispatchToken mismatch for execution ${payload.executionId}`);
+      }
+      execution.cancelRequested = true;
+      requestExecutionTermination(execution);
+      return { accepted: true };
+    };
+    const stopAllOrchestratorExecutions = async () => {
+      const executions = Array.from(executionIdToManagedExecution.values());
+      if (executions.length === 0) {
+        return;
+      }
+      logger.logger.debug(`[ORCHESTRATOR] Stopping ${executions.length} running orchestrator execution(s)`);
+      for (const execution of executions) {
+        execution.cancelRequested = true;
+        requestExecutionTermination(execution);
+      }
+      const deadline = Date.now() + ORCHESTRATOR_SHUTDOWN_WAIT_MS;
+      while (executionIdToManagedExecution.size > 0 && Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+    };
+    const onHappySessionWebhook = (sessionId, sessionMetadata) => {
+      logger.logger.debugLargeJson(`[DAEMON RUN] Session reported`, sessionMetadata);
+      const pid = sessionMetadata.hostPid;
+      if (!pid) {
+        logger.logger.debug(`[DAEMON RUN] Session webhook missing hostPid for sessionId: ${sessionId}`);
+        return;
+      }
+      logger.logger.debug(`[DAEMON RUN] Session webhook: ${sessionId}, PID: ${pid}, started by: ${sessionMetadata.startedBy || "unknown"}`);
+      logger.logger.debug(`[DAEMON RUN] Current tracked sessions before webhook: ${Array.from(pidToTrackedSession.keys()).join(", ")}`);
+      const existingSession = pidToTrackedSession.get(pid);
+      if (existingSession && existingSession.startedBy === "daemon") {
+        existingSession.happySessionId = sessionId;
+        existingSession.happySessionMetadataFromLocalWebhook = sessionMetadata;
+        logger.logger.debug(`[DAEMON RUN] Updated daemon-spawned session ${sessionId} with metadata`);
+        const awaiter = pidToAwaiter.get(pid);
+        if (awaiter) {
+          pidToAwaiter.delete(pid);
+          awaiter(existingSession);
+          logger.logger.debug(`[DAEMON RUN] Resolved session awaiter for PID ${pid}`);
+        }
+      } else if (!existingSession) {
+        const trackedSession = {
+          startedBy: "happy directly - likely by user from terminal",
+          happySessionId: sessionId,
+          happySessionMetadataFromLocalWebhook: sessionMetadata,
+          pid
+        };
+        pidToTrackedSession.set(pid, trackedSession);
+        logger.logger.debug(`[DAEMON RUN] Registered externally-started session ${sessionId}`);
+      }
+    };
+    const spawnSession = async (options) => {
+      logger.logger.debugLargeJson("[DAEMON RUN] Spawning session", options);
+      const { directory, sessionId, resumeSessionId: rawResumeSessionId, sessionTitle, skipForkSession, machineId: machineId2, approvedNewDirectoryCreation = true, intent } = options;
+      const isClaudeAgent = !options.agent || options.agent === "claude";
+      const resumeSessionId = intent === "resume" ? rawResumeSessionId : void 0;
+      if (rawResumeSessionId && intent !== "resume") {
+        logger.logger.debug('[DAEMON RUN] Ignoring resumeSessionId because intent is not "resume"', { rawResumeSessionId, intent });
+      }
+      let directoryCreated = false;
+      try {
+        await fs$1.access(directory);
+        logger.logger.debug(`[DAEMON RUN] Directory exists: ${directory}`);
+      } catch (error) {
+        logger.logger.debug(`[DAEMON RUN] Directory doesn't exist, creating: ${directory}`);
+        if (!approvedNewDirectoryCreation) {
+          logger.logger.debug(`[DAEMON RUN] Directory creation not approved for: ${directory}`);
+          return {
+            type: "requestToApproveDirectoryCreation",
+            directory
+          };
+        }
+        try {
+          await fs$1.mkdir(directory, { recursive: true });
+          logger.logger.debug(`[DAEMON RUN] Successfully created directory: ${directory}`);
+          directoryCreated = true;
+        } catch (mkdirError) {
+          let errorMessage = `Unable to create directory at '${directory}'. `;
+          if (mkdirError.code === "EACCES") {
+            errorMessage += `Permission denied. You don't have write access to create a folder at this location. Try using a different path or check your permissions.`;
+          } else if (mkdirError.code === "ENOTDIR") {
+            errorMessage += `A file already exists at this path or in the parent path. Cannot create a directory here. Please choose a different location.`;
+          } else if (mkdirError.code === "ENOSPC") {
+            errorMessage += `No space left on device. Your disk is full. Please free up some space and try again.`;
+          } else if (mkdirError.code === "EROFS") {
+            errorMessage += `The file system is read-only. Cannot create directories here. Please choose a writable location.`;
+          } else {
+            errorMessage += `System error: ${mkdirError.message || mkdirError}. Please verify the path is valid and you have the necessary permissions.`;
+          }
+          logger.logger.debug(`[DAEMON RUN] Directory creation failed: ${errorMessage}`);
+          return {
+            type: "error",
+            errorMessage
+          };
+        }
+      }
+      try {
+        const authEnv = {};
+        if (options.token) {
+          if (options.agent === "codex") {
+            const codexHomeDir = tmp__namespace.dirSync();
+            fs$1.writeFile(path$1.join(codexHomeDir.name, "auth.json"), options.token);
+            authEnv.CODEX_HOME = codexHomeDir.name;
+          } else {
+            authEnv.CLAUDE_CODE_OAUTH_TOKEN = options.token;
+          }
+        }
+        let profileEnv = {};
+        if (options.environmentVariables && Object.keys(options.environmentVariables).length > 0) {
+          profileEnv = options.environmentVariables;
+          logger.logger.info(`[DAEMON RUN] Using GUI-provided profile environment variables (${Object.keys(profileEnv).length} vars)`);
+          logger.logger.debug(`[DAEMON RUN] GUI profile env var keys: ${Object.keys(profileEnv).join(", ")}`);
+        } else {
+          try {
+            const settings = await logger.readSettings();
+            if (settings.activeProfileId) {
+              logger.logger.debug(`[DAEMON RUN] No GUI profile provided, loading CLI local active profile: ${settings.activeProfileId}`);
+              profileEnv = await getProfileEnvironmentVariablesForAgent(
+                settings.activeProfileId,
+                options.agent || "claude"
+              );
+              logger.logger.debug(`[DAEMON RUN] Loaded ${Object.keys(profileEnv).length} environment variables from CLI local profile for agent ${options.agent || "claude"}`);
+              logger.logger.debug(`[DAEMON RUN] CLI profile env var keys: ${Object.keys(profileEnv).join(", ")}`);
+            } else {
+              logger.logger.debug("[DAEMON RUN] No CLI local active profile set");
+            }
+          } catch (error) {
+            logger.logger.debug("[DAEMON RUN] Failed to load CLI local profile environment variables:", error);
+          }
+        }
+        let extraEnv = { ...profileEnv, ...authEnv };
+        if (resumeSessionId && isClaudeAgent) {
+          extraEnv.HAPPY_CLAUDE_BACKFILL = "1";
+          extraEnv.HAPPY_CLAUDE_BACKFILL_MAX_MESSAGES = "200";
+          extraEnv.HAPPY_CLAUDE_BACKFILL_MAX_USER_MESSAGES = "20";
+          extraEnv.HAPPY_CLAUDE_RESUME_SESSION_ID = resumeSessionId;
+          if (skipForkSession) {
+            extraEnv.HAPPY_CLAUDE_SKIP_FORK_SESSION = "1";
+          }
+        }
+        if (resumeSessionId && options.agent === "gemini") {
+          extraEnv.HAPPY_GEMINI_RESUME_SESSION_ID = resumeSessionId;
+          extraEnv.HAPPY_GEMINI_BACKFILL = "1";
+        }
+        if (resumeSessionId && options.agent === "codex") {
+          extraEnv.HAPPY_CODEX_RESUME_FILE = resumeSessionId;
+          extraEnv.HAPPY_CODEX_BACKFILL = "1";
+        }
+        if (sessionTitle) {
+          extraEnv.HAPPY_SESSION_TITLE = sessionTitle;
+        }
+        if (options.worktreeBasePath) {
+          extraEnv.HAPPY_WORKTREE_BASE_PATH = options.worktreeBasePath;
+        }
+        if (options.worktreeBranchName) {
+          extraEnv.HAPPY_WORKTREE_BRANCH_NAME = options.worktreeBranchName;
+        }
+        if (options.workspaceRepos && options.workspaceRepos.length > 0) {
+          extraEnv.HAPPY_WORKSPACE_REPOS = JSON.stringify(options.workspaceRepos);
+        }
+        if (options.workspacePath) {
+          extraEnv.HAPPY_WORKSPACE_PATH = options.workspacePath;
+        }
+        if (options.mcpServers && options.mcpServers.length > 0) {
+          extraEnv.HAPPY_EXTRA_MCP_SERVERS = JSON.stringify(options.mcpServers);
+        }
+        logger.logger.debug(`[DAEMON RUN] Final environment variable keys (before expansion) (${Object.keys(extraEnv).length}): ${Object.keys(extraEnv).join(", ")}`);
+        extraEnv = expandEnvironmentVariables(extraEnv, process.env);
+        logger.logger.debug(`[DAEMON RUN] After variable expansion: ${Object.keys(extraEnv).join(", ")}`);
+        const potentialAuthVars = ["ANTHROPIC_AUTH_TOKEN", "CLAUDE_CODE_OAUTH_TOKEN", "OPENAI_API_KEY", "CODEX_HOME", "AZURE_OPENAI_API_KEY", "TOGETHER_API_KEY"];
+        const unexpandedAuthVars = potentialAuthVars.filter((varName) => {
+          const value = extraEnv[varName];
+          return value && typeof value === "string" && value.includes("${");
+        });
+        if (unexpandedAuthVars.length > 0) {
+          const missingVarDetails = unexpandedAuthVars.map((authVar) => {
+            const value = extraEnv[authVar];
+            const unresolvedMatch = value?.match(/\$\{([A-Z_][A-Z0-9_]*)(:-[^}]*)?\}/);
+            const missingVar = unresolvedMatch ? unresolvedMatch[1] : "unknown";
+            return `${authVar} references \${${missingVar}} which is not defined`;
+          });
+          const errorMessage = `Authentication will fail - environment variables not found in daemon: ${missingVarDetails.join("; ")}. Ensure these variables are set in the daemon's environment (not just your shell) before starting sessions.`;
+          logger.logger.warn(`[DAEMON RUN] ${errorMessage}`);
+          return {
+            type: "error",
+            errorMessage
+          };
+        }
+        if (options.repoScripts && options.repoScripts.length > 0) {
+          const sequentialScripts = options.repoScripts.filter((s) => s.setupScript && !s.parallelSetup);
+          const parallelScripts = options.repoScripts.filter((s) => s.setupScript && s.parallelSetup);
+          for (const script of sequentialScripts) {
+            logger.logger.info(`[DAEMON] Running setup script for ${script.repoDisplayName}...`);
+            try {
+              child_process.execSync(script.setupScript, { cwd: script.worktreePath, stdio: "pipe", timeout: 3e5 });
+              logger.logger.info(`[DAEMON] Setup script completed for ${script.repoDisplayName}`);
+            } catch (err) {
+              logger.logger.warn(`[DAEMON] Setup script failed for ${script.repoDisplayName}: ${err.message}`);
+            }
+          }
+          for (const script of parallelScripts) {
+            logger.logger.info(`[DAEMON] Running parallel setup for ${script.repoDisplayName}...`);
+            const child = child_process.exec(script.setupScript, { cwd: script.worktreePath });
+            child.on("exit", (code) => {
+              if (code === 0) {
+                logger.logger.info(`[DAEMON] Parallel setup completed for ${script.repoDisplayName}`);
+              } else {
+                logger.logger.warn(`[DAEMON] Parallel setup failed for ${script.repoDisplayName} (exit code ${code})`);
+              }
+            });
+          }
+        }
+        const tmuxAvailable = await isTmuxAvailable();
+        let useTmux = tmuxAvailable;
+        let tmuxSessionName = extraEnv.TMUX_SESSION_NAME;
+        if (!tmuxAvailable || tmuxSessionName === void 0) {
+          useTmux = false;
+          if (tmuxSessionName !== void 0) {
+            logger.logger.debug(`[DAEMON RUN] tmux session name specified but tmux not available, falling back to regular spawning`);
+          }
+        }
+        if (useTmux && tmuxSessionName !== void 0) {
+          const sessionDesc = tmuxSessionName || "current/most recent session";
+          logger.logger.debug(`[DAEMON RUN] Attempting to spawn session in tmux: ${sessionDesc}`);
+          const tmux = getTmuxUtilities(tmuxSessionName);
+          const cliPath = path$1.join(projectPath.projectPath(), "dist", "index.mjs");
+          const agent = options.agent === "gemini" ? "gemini" : options.agent === "codex" ? "codex" : "claude";
+          const forkFlag = skipForkSession ? "" : " --fork-session";
+          const resumeArgs = resumeSessionId && isClaudeAgent ? ` --resume ${resumeSessionId}${forkFlag}` : "";
+          const fullCommand = `node --no-warnings --no-deprecation ${cliPath} ${agent} --happy-starting-mode remote --started-by daemon${resumeArgs}`;
+          const windowName = `happy-${Date.now()}-${agent}`;
+          const tmuxEnv = {};
+          const sanitizedDaemonEnv = stripSessionScopedHappyEnv(process.env);
+          for (const [key, value] of Object.entries(sanitizedDaemonEnv)) {
+            if (value !== void 0) {
+              tmuxEnv[key] = value;
+            }
+          }
+          Object.assign(tmuxEnv, extraEnv);
+          const tmuxResult = await tmux.spawnInTmux([fullCommand], {
+            sessionName: tmuxSessionName,
+            windowName,
+            cwd: directory
+          }, tmuxEnv);
+          if (tmuxResult.success) {
+            logger.logger.debug(`[DAEMON RUN] Successfully spawned in tmux session: ${tmuxResult.sessionId}, PID: ${tmuxResult.pid}`);
+            if (!tmuxResult.pid) {
+              throw new Error("Tmux window created but no PID returned");
+            }
+            const trackedSession = {
+              startedBy: "daemon",
+              pid: tmuxResult.pid,
+              // Real PID from tmux -P flag
+              tmuxSessionId: tmuxResult.sessionId,
+              directoryCreated,
+              message: directoryCreated ? `The path '${directory}' did not exist. We created a new folder and spawned a new session in tmux session '${tmuxSessionName}'. Use 'tmux attach -t ${tmuxSessionName}' to view the session.` : `Spawned new session in tmux session '${tmuxSessionName}'. Use 'tmux attach -t ${tmuxSessionName}' to view the session.`,
+              repoScripts: options.repoScripts
+            };
+            pidToTrackedSession.set(tmuxResult.pid, trackedSession);
+            logger.logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${tmuxResult.pid} (tmux)`);
+            return new Promise((resolve) => {
+              const timeout = setTimeout(() => {
+                pidToAwaiter.delete(tmuxResult.pid);
+                logger.logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${tmuxResult.pid} (tmux)`);
+                resolve({
+                  type: "error",
+                  errorMessage: `Session webhook timeout for PID ${tmuxResult.pid} (tmux)`
+                });
+              }, 15e3);
+              pidToAwaiter.set(tmuxResult.pid, (completedSession) => {
+                clearTimeout(timeout);
+                logger.logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook (tmux)`);
+                resolve({
+                  type: "success",
+                  sessionId: completedSession.happySessionId
+                });
+              });
+            });
+          } else {
+            logger.logger.debug(`[DAEMON RUN] Failed to spawn in tmux: ${tmuxResult.error}, falling back to regular spawning`);
+            useTmux = false;
+          }
+        }
+        if (!useTmux) {
+          logger.logger.debug(`[DAEMON RUN] Using regular process spawning`);
+          let agentCommand;
+          switch (options.agent) {
+            case "claude":
+            case void 0:
+              agentCommand = "claude";
+              break;
+            case "codex":
+              agentCommand = "codex";
+              break;
+            case "gemini":
+              agentCommand = "gemini";
+              break;
+            default:
+              return {
+                type: "error",
+                errorMessage: `Unsupported agent type: '${options.agent}'. Please update your CLI to the latest version.`
+              };
+          }
+          const args = [
+            agentCommand,
+            "--happy-starting-mode",
+            "remote",
+            "--started-by",
+            "daemon"
+          ];
+          if (resumeSessionId && isClaudeAgent) {
+            args.push("--resume", resumeSessionId);
+            if (!skipForkSession) {
+              args.push("--fork-session");
+            }
+          }
+          const happyProcess = spawnHappyCLI.spawnHappyCLI(args, {
+            cwd: directory,
+            detached: true,
+            // Sessions stay alive when daemon stops
+            stdio: ["ignore", "pipe", "pipe"],
+            // Capture stdout/stderr for debugging
+            env: {
+              // Defense-in-depth: even if startDaemon's entry sanitization is
+              // bypassed somehow, the spawn site re-strips session-scoped
+              // HAPPY_* keys before extraEnv adds them back deterministically.
+              ...stripSessionScopedHappyEnv(process.env),
+              ...extraEnv
+            }
+          });
+          if (logger.isDebug()) {
+            happyProcess.stdout?.on("data", (data) => {
+              logger.logger.debug(`[DAEMON RUN] Child stdout: ${data.toString()}`);
+            });
+            happyProcess.stderr?.on("data", (data) => {
+              logger.logger.debug(`[DAEMON RUN] Child stderr: ${data.toString()}`);
+            });
+          }
+          if (!happyProcess.pid) {
+            logger.logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
+            return {
+              type: "error",
+              errorMessage: "Failed to spawn Happy process - no PID returned"
+            };
+          }
+          logger.logger.debug(`[DAEMON RUN] Spawned process with PID ${happyProcess.pid}`);
+          const trackedSession = {
+            startedBy: "daemon",
+            pid: happyProcess.pid,
+            childProcess: happyProcess,
+            directoryCreated,
+            message: directoryCreated ? `The path '${directory}' did not exist. We created a new folder and spawned a new session there.` : void 0,
+            repoScripts: options.repoScripts
+          };
+          pidToTrackedSession.set(happyProcess.pid, trackedSession);
+          happyProcess.on("exit", (code, signal) => {
+            logger.logger.debug(`[DAEMON RUN] Child PID ${happyProcess.pid} exited with code ${code}, signal ${signal}`);
+            if (happyProcess.pid) {
+              onChildExited(happyProcess.pid);
+            }
+          });
+          happyProcess.on("error", (error) => {
+            logger.logger.debug(`[DAEMON RUN] Child process error:`, error);
+            if (happyProcess.pid) {
+              onChildExited(happyProcess.pid);
+            }
+          });
+          logger.logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${happyProcess.pid}`);
+          return new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+              pidToAwaiter.delete(happyProcess.pid);
+              logger.logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${happyProcess.pid}`);
+              resolve({
+                type: "error",
+                errorMessage: `Session webhook timeout for PID ${happyProcess.pid}`
+              });
+            }, 15e3);
+            pidToAwaiter.set(happyProcess.pid, (completedSession) => {
+              clearTimeout(timeout);
+              logger.logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook`);
+              resolve({
+                type: "success",
+                sessionId: completedSession.happySessionId
+              });
+            });
+          });
+        }
+        return {
+          type: "error",
+          errorMessage: "Unexpected error in session spawning"
+        };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.logger.debug("[DAEMON RUN] Failed to spawn session:", error);
+        return {
+          type: "error",
+          errorMessage: `Failed to spawn session: ${errorMessage}`
+        };
+      }
+    };
+    const stopSession = (sessionId) => {
+      logger.logger.debug(`[DAEMON RUN] Attempting to stop session ${sessionId}`);
+      for (const [pid, session] of pidToTrackedSession.entries()) {
+        if (session.happySessionId === sessionId || sessionId.startsWith("PID-") && pid === parseInt(sessionId.replace("PID-", ""))) {
+          if (session.startedBy === "daemon" && session.childProcess) {
+            try {
+              session.childProcess.kill("SIGTERM");
+              logger.logger.debug(`[DAEMON RUN] Sent SIGTERM to daemon-spawned session ${sessionId}`);
+            } catch (error) {
+              logger.logger.debug(`[DAEMON RUN] Failed to kill session ${sessionId}:`, error);
+            }
+          } else {
+            try {
+              process.kill(pid, "SIGTERM");
+              logger.logger.debug(`[DAEMON RUN] Sent SIGTERM to external session PID ${pid}`);
+            } catch (error) {
+              logger.logger.debug(`[DAEMON RUN] Failed to kill external session PID ${pid}:`, error);
+            }
+          }
+          pidToTrackedSession.delete(pid);
+          logger.logger.debug(`[DAEMON RUN] Removed session ${sessionId} from tracking`);
+          return true;
+        }
+      }
+      logger.logger.debug(`[DAEMON RUN] Session ${sessionId} not found`);
+      return false;
+    };
+    const runCleanupScripts = (session) => {
+      if (!session.repoScripts || session.repoScripts.length === 0) return;
+      for (const script of session.repoScripts) {
+        if (!script.cleanupScript) continue;
+        try {
+          const status = child_process.execSync("git status --porcelain", {
+            cwd: script.worktreePath,
+            encoding: "utf-8",
+            timeout: 1e4
+          });
+          if (status.trim()) {
+            logger.logger.info(`[DAEMON] Running cleanup script for ${script.repoDisplayName}...`);
+            child_process.execSync(script.cleanupScript, {
+              cwd: script.worktreePath,
+              stdio: "pipe",
+              timeout: 3e5
+            });
+            logger.logger.info(`[DAEMON] Cleanup script completed for ${script.repoDisplayName}`);
+          } else {
+            logger.logger.debug(`[DAEMON] No changes in ${script.repoDisplayName}, skipping cleanup`);
+          }
+        } catch (err) {
+          logger.logger.warn(`[DAEMON] Cleanup script failed for ${script.repoDisplayName}: ${err.message}`);
+        }
+      }
+    };
+    const onChildExited = (pid) => {
+      logger.logger.debug(`[DAEMON RUN] Removing exited process PID ${pid} from tracking`);
+      const session = pidToTrackedSession.get(pid);
+      if (session) {
+        runCleanupScripts(session);
+      }
+      pidToTrackedSession.delete(pid);
+    };
+    const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
+      getChildren: getCurrentChildren,
+      stopSession,
+      spawnSession,
+      requestShutdown: () => requestShutdown("happy-cli"),
+      onHappySessionWebhook
+    });
+    const fileState = {
+      pid: process.pid,
+      httpPort: controlPort,
+      startTime: (/* @__PURE__ */ new Date()).toLocaleString(),
+      startedWithCliVersion: logger.packageJson.version,
+      daemonLogPath: logger.logger.logFilePath
+    };
+    logger.writeDaemonState(fileState);
+    logger.logger.debug("[DAEMON RUN] Daemon state written");
+    const initialDaemonState = {
+      status: "offline",
+      pid: process.pid,
+      httpPort: controlPort,
+      startedAt: Date.now()
+    };
+    api$1 = await api.ApiClient.create(credentials);
+    const machineMetadata = await buildMachineMetadata();
+    const machine = await api$1.getOrCreateMachine({
+      machineId,
+      metadata: machineMetadata,
+      daemonState: initialDaemonState
+    });
+    logger.logger.debug(`[DAEMON RUN] Machine registered: ${machine.id}`);
+    const apiMachine = api$1.machineSyncClient(machine, initialDaemonState);
+    apiMachine.setRPCHandlers({
+      spawnSession,
+      stopSession,
+      requestShutdown: () => requestShutdown("happy-app"),
+      orchestratorDispatch: handleOrchestratorDispatch,
+      orchestratorCancel: handleOrchestratorCancel
+    });
+    apiMachine.connect();
+    apiMachine.updateMachineMetadata((current) => ({ ...current, ...machineMetadata })).catch((error) => {
+      logger.logger.debug("[DAEMON RUN] Failed to update machine metadata", error);
+    });
+    const heartbeatIntervalMsRaw = Number(process.env.HAPPY_DAEMON_HEARTBEAT_INTERVAL);
+    const heartbeatIntervalMs = Number.isFinite(heartbeatIntervalMsRaw) && heartbeatIntervalMsRaw > 0 ? heartbeatIntervalMsRaw : 6e4;
+    let heartbeatRunning = false;
+    const restartOnStaleVersionAndHeartbeat = setInterval(async () => {
+      if (heartbeatRunning) {
+        return;
+      }
+      heartbeatRunning = true;
+      if (logger.isDebug()) {
+        logger.logger.debug(`[DAEMON RUN] Health check started at ${(/* @__PURE__ */ new Date()).toLocaleString()}`);
+      }
+      for (const [pid, _] of pidToTrackedSession.entries()) {
+        try {
+          process.kill(pid, 0);
+        } catch (error) {
+          logger.logger.debug(`[DAEMON RUN] Removing stale session with PID ${pid} (process no longer exists)`);
+          onChildExited(pid);
+        }
+      }
+      let projectVersion;
+      try {
+        projectVersion = JSON.parse(fs$2.readFileSync(path$1.join(projectPath.projectPath(), "package.json"), "utf-8")).version;
+      } catch (error) {
+        logger.logger.debug("[DAEMON RUN] Failed to read package.json for version check, skipping this heartbeat", error);
+        heartbeatRunning = false;
+        return;
+      }
+      if (projectVersion !== logger.configuration.currentCliVersion) {
+        logger.logger.debug("[DAEMON RUN] Daemon is outdated, triggering self-restart with latest version, clearing heartbeat interval");
+        clearInterval(restartOnStaleVersionAndHeartbeat);
+        const supervised = process.env.HAPPY_DAEMON_SUPERVISED === "1" || process.env.XPC_SERVICE_NAME === install.PLIST_LABEL;
+        if (supervised) {
+          logger.logger.debug("[DAEMON RUN] Supervised daemon is outdated, exiting non-zero so the service manager restarts us with the new version");
+          process.exit(1);
+        }
+        try {
+          spawnHappyCLI.spawnHappyCLI(["daemon", "start"], {
+            detached: true,
+            stdio: "ignore"
+          });
+        } catch (error) {
+          logger.logger.debug("[DAEMON RUN] Failed to spawn new daemon, this is quite likely to happen during integration tests as we are cleaning out dist/ directory", error);
+        }
+        logger.logger.debug("[DAEMON RUN] Hanging for a bit - waiting for CLI to kill us because we are running outdated version of the code");
+        await new Promise((resolve) => setTimeout(resolve, 1e4));
+        process.exit(0);
+      }
+      const daemonState = await logger.readDaemonState();
+      if (daemonState && daemonState.pid !== process.pid) {
+        logger.logger.debug("[DAEMON RUN] Somehow a different daemon was started without killing us. We should kill ourselves.");
+        requestShutdown("exception", "A different daemon was started without killing us. We should kill ourselves.");
+      }
+      try {
+        const updatedState = {
+          pid: process.pid,
+          httpPort: controlPort,
+          startTime: fileState.startTime,
+          startedWithCliVersion: logger.packageJson.version,
+          lastHeartbeat: (/* @__PURE__ */ new Date()).toLocaleString(),
+          daemonLogPath: fileState.daemonLogPath
+        };
+        logger.writeDaemonState(updatedState);
+        if (logger.isDebug()) {
+          logger.logger.debug(`[DAEMON RUN] Health check completed at ${updatedState.lastHeartbeat}`);
+        }
+      } catch (error) {
+        logger.logger.debug("[DAEMON RUN] Failed to write heartbeat", error);
+      }
+      heartbeatRunning = false;
+    }, heartbeatIntervalMs);
+    const cleanupAndShutdown = async (source, errorMessage) => {
+      logger.logger.debug(`[DAEMON RUN] Starting proper cleanup (source: ${source}, errorMessage: ${errorMessage})...`);
+      if (restartOnStaleVersionAndHeartbeat) {
+        clearInterval(restartOnStaleVersionAndHeartbeat);
+        logger.logger.debug("[DAEMON RUN] Health check interval cleared");
+      }
+      await apiMachine.updateDaemonState((state) => ({
+        ...state,
+        status: "shutting-down",
+        shutdownRequestedAt: Date.now(),
+        shutdownSource: source
+      }));
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      await stopAllOrchestratorExecutions();
+      apiMachine.shutdown();
+      await stopControlServer();
+      await controlClient.cleanupDaemonState();
+      await stopCaffeinate();
+      await logger.releaseDaemonLock(daemonLockHandle);
+      logger.logger.debug("[DAEMON RUN] Cleanup completed, exiting process");
+      process.exit(0);
+    };
+    logger.logger.debug("[DAEMON RUN] Daemon started successfully, waiting for shutdown request");
+    const shutdownRequest = await resolvesWhenShutdownRequested;
+    await cleanupAndShutdown(shutdownRequest.source, shutdownRequest.errorMessage);
+  } catch (error) {
+    logger.logger.debug("[DAEMON RUN][FATAL] Failed somewhere unexpectedly - exiting with code 1", error);
+    process.exit(1);
+  }
+}
+
+var run = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    buildMachineMetadata: buildMachineMetadata,
+    initialMachineMetadata: initialMachineMetadata,
+    startDaemon: startDaemon
+});
+
+exports.initialMachineMetadata = initialMachineMetadata;
+exports.run = run;
+exports.startCaffeinate = startCaffeinate;
+exports.stopCaffeinate = stopCaffeinate;