@zonease/happy 0.6.42 → 0.6.43

package/dist/registerKillSessionHandler-MoLdSQxM.cjs

@@ -0,0 +1,411 @@
+'use strict';
+
+var path = require('node:path');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
+var node_http = require('node:http');
+var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+var types_js = require('@modelcontextprotocol/sdk/types.js');
+var z = require('zod');
+var logger = require('./persistence-D7zNFI-d.cjs');
+var deviceKeys = require('./deviceKeys-CdW-HPnz.cjs');
+var node_crypto = require('node:crypto');
+var prompt = require('./prompt-BTWDZZO0.cjs');
+require('./mcpToolSchemas-DK42yoZ_.cjs');
+require('./index-BeKrqPYR.cjs');
+var node_child_process = require('node:child_process');
+require('axios');
+require('node:events');
+require('socket.io-client');
+require('./api-B-PlVQY6.cjs');
+require('tweetnacl');
+require('ws');
+require('crypto');
+require('@stablelib/base64');
+require('node:os');
+require('node:fs/promises');
+require('node:fs');
+require('node:readline');
+require('expo-server-sdk');
+require('chalk');
+require('./types-DWeB7aqh.cjs');
+
+function createMcpServer(client, options) {
+  const mcp = new mcp_js.McpServer({
+    name: "Happy MCP",
+    version: "1.0.0"
+  });
+  const handler = async (title) => {
+    logger.logger.debug("[happyMCP] Changing title to:", title);
+    if (client.isTitlePinned) {
+      return { success: false, error: "Title is pinned by user and cannot be changed automatically" };
+    }
+    try {
+      client.sendClaudeSessionMessage({
+        type: "summary",
+        summary: title,
+        leafUuid: node_crypto.randomUUID()
+      });
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: String(error) };
+    }
+  };
+  mcp.registerTool("device_list", {
+    description: "List enrolled Happy devices (servers and computers) with their online state. Use before device_exec when you need a device id.",
+    title: "List Devices",
+    inputSchema: {}
+  }, async () => {
+    const credentials = await logger.readCredentials();
+    if (!credentials) {
+      return { content: [{ type: "text", text: "No Happy credentials on this machine." }] };
+    }
+    try {
+      const devices = await deviceKeys.listDevices(credentials);
+      const target = client.targetDevices.map((device) => device.id);
+      const lines = devices.map((device) => {
+        const marks = [device.active ? "online" : "offline"];
+        if (target.includes(device.id)) marks.push("session default");
+        return `${device.id}  ${device.name}${device.platform ? ` (${device.platform})` : ""}  [${marks.join(", ")}]${device.description ? `  \u2014 ${device.description}` : ""}`;
+      });
+      return { content: [{ type: "text", text: lines.length ? lines.join("\n") : "No devices enrolled yet." }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Failed to list devices: ${error instanceof Error ? error.message : String(error)}` }] };
+    }
+  });
+  mcp.registerTool("device_exec", {
+    description: "Run a shell command on an enrolled device (a server or computer registered in Happy). Omit deviceId to use the device the user selected for this session. Returns stdout, stderr and exit code.",
+    title: "Run Command on Device",
+    inputSchema: {
+      command: z.z.string().describe("Shell command to run on the device"),
+      deviceId: z.z.string().optional().describe("Target device id. Defaults to the session's selected device."),
+      cwd: z.z.string().optional().describe("Working directory on the device"),
+      timeout: z.z.number().optional().describe("Timeout in milliseconds (default 60000)")
+    }
+  }, async (args) => {
+    const credentials = await logger.readCredentials();
+    if (!credentials) {
+      return { content: [{ type: "text", text: "No Happy credentials on this machine." }] };
+    }
+    const targets = client.targetDevices;
+    const deviceId = args.deviceId || (targets.length === 1 ? targets[0].id : null);
+    if (!deviceId && targets.length > 1) {
+      return { content: [{ type: "text", text: `This session targets several devices \u2014 pass deviceId: ${targets.map((device) => `${device.name} (${device.id})`).join(", ")}` }] };
+    }
+    if (!deviceId) {
+      return { content: [{ type: "text", text: "No device selected for this session. Pick one in the app or pass deviceId (see device_list)." }] };
+    }
+    try {
+      const result = await deviceKeys.deviceExec(client.rpcSocket, credentials, deviceId, args.command, {
+        cwd: args.cwd,
+        timeout: args.timeout,
+        deviceKeyBase64: targets.find((device) => device.id === deviceId)?.key ?? null
+      });
+      const parts = [`exit code: ${result.exitCode}`];
+      if (result.stdout) parts.push(`stdout:
+${result.stdout}`);
+      if (result.stderr) parts.push(`stderr:
+${result.stderr}`);
+      return { content: [{ type: "text", text: parts.join("\n\n") }] };
+    } catch (error) {
+      return { content: [{ type: "text", text: `Device command failed: ${error instanceof Error ? error.message : String(error)}` }] };
+    }
+  });
+  mcp.registerTool("change_title", {
+    description: "Change the title of the current chat session",
+    title: "Change Chat Title",
+    inputSchema: {
+      title: z.z.string().describe("The new title for the chat session")
+    }
+  }, async (args) => {
+    const response = await handler(args.title);
+    logger.logger.debug("[happyMCP] Response:", response);
+    if (response.success) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Successfully changed chat title to: "${args.title}"`
+          }
+        ],
+        isError: false
+      };
+    } else {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to change chat title: ${response.error || "Unknown error"}`
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  mcp.registerTool("preview_html", {
+    description: "Preview an HTML page in the client app. The HTML must be a complete, self-contained document with all CSS and JS inlined.",
+    title: "Preview HTML",
+    inputSchema: {
+      html: z.z.string().describe("Complete self-contained HTML document string"),
+      title: z.z.string().optional().describe("Display title for the preview")
+    }
+  }, async (args) => {
+    logger.logger.debug("[happyMCP] Preview HTML:", args.title || "Untitled");
+    return {
+      content: [{
+        type: "text",
+        text: `HTML preview ready: ${args.title || "Untitled"}`
+      }],
+      isError: false
+    };
+  });
+  return mcp;
+}
+async function startHappyServer(client) {
+  const transports = /* @__PURE__ */ new Map();
+  const enableOrchestratorTools = prompt.shouldEnableOrchestratorTools();
+  const toolNames = ["change_title", "preview_html", "device_list", "device_exec"];
+  const originalConsoleError = console.error;
+  console.error = (...args) => {
+    logger.logger.debug("[happyMCP] console.error:", ...args);
+    originalConsoleError.apply(console, args);
+  };
+  const server = node_http.createServer(async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    logger.logger.debug("[happyMCP] Received request:", req.method, req.url, "sessionId:", sessionId);
+    try {
+      if (req.method === "POST") {
+        const body = await readRequestBody(req);
+        const parsedBody = JSON.parse(body);
+        let transport;
+        if (sessionId && transports.has(sessionId)) {
+          transport = transports.get(sessionId);
+          logger.logger.debug("[happyMCP] Reusing transport for session:", sessionId);
+        } else if (!sessionId && types_js.isInitializeRequest(parsedBody)) {
+          logger.logger.debug("[happyMCP] New initialize request, creating transport");
+          transport = new streamableHttp_js.StreamableHTTPServerTransport({
+            sessionIdGenerator: () => node_crypto.randomUUID(),
+            onsessioninitialized: (newSessionId) => {
+              logger.logger.debug("[happyMCP] Session initialized:", newSessionId);
+              transports.set(newSessionId, transport);
+            }
+          });
+          transport.onclose = () => {
+            const sid = transport.sessionId;
+            if (sid && transports.has(sid)) {
+              logger.logger.debug("[happyMCP] Transport closed, removing session:", sid);
+              transports.delete(sid);
+            }
+          };
+          transport.onerror = (error) => {
+            logger.logger.debug("[happyMCP] Transport error:", error);
+          };
+          const mcp = createMcpServer(client, { enableOrchestratorTools });
+          await mcp.connect(transport);
+          await transport.handleRequest(req, res, parsedBody);
+          logger.logger.debug("[happyMCP] Initialize request handled successfully");
+          return;
+        } else {
+          logger.logger.debug("[happyMCP] Bad request: no session ID and not initialize");
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Bad Request: No valid session ID provided"
+            },
+            id: null
+          }));
+          return;
+        }
+        await transport.handleRequest(req, res, parsedBody);
+        logger.logger.debug("[happyMCP] Request handled successfully");
+      } else if (req.method === "GET" || req.method === "DELETE") {
+        if (!sessionId || !transports.has(sessionId)) {
+          logger.logger.debug("[happyMCP] Bad request: invalid session for GET/DELETE");
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Invalid or missing session ID");
+          return;
+        }
+        const transport = transports.get(sessionId);
+        await transport.handleRequest(req, res);
+        logger.logger.debug("[happyMCP] GET/DELETE request handled successfully");
+      } else {
+        res.writeHead(405, { "Content-Type": "text/plain" });
+        res.end("Method not allowed");
+      }
+    } catch (error) {
+      logger.logger.debug("[happyMCP] Error handling request:", error);
+      if (!res.headersSent) {
+        res.writeHead(500).end();
+      }
+    }
+  });
+  const baseUrl = await new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolve(new URL(`http://127.0.0.1:${addr.port}`));
+    });
+  });
+  logger.logger.debug("[happyMCP] Server started at:", baseUrl.toString());
+  return {
+    url: baseUrl.toString(),
+    toolNames,
+    stop: async () => {
+      logger.logger.debug("[happyMCP] Stopping server");
+      for (const [sessionId, transport] of transports) {
+        logger.logger.debug("[happyMCP] Closing transport for session:", sessionId);
+        try {
+          await transport.close();
+        } catch (error) {
+          logger.logger.debug("[happyMCP] Error closing transport:", error);
+        }
+      }
+      transports.clear();
+      server.close();
+    }
+  };
+}
+function readRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", () => resolve(body));
+    req.on("error", reject);
+  });
+}
+
+const getBridgeCommand = () => path.join(projectPath.projectPath(), "bin", "happy-mcp.mjs");
+function adaptForClaude(def) {
+  return { type: "http", url: def.url, ...def.headers && { headers: def.headers } };
+}
+function adaptForStdio(def) {
+  const args = ["--url", def.url];
+  if (def.headers) {
+    for (const [k, v] of Object.entries(def.headers)) {
+      args.push("--header", `${k}: ${v}`);
+    }
+  }
+  return { command: getBridgeCommand(), args };
+}
+function adaptForHttp(def) {
+  return { type: "http", url: def.url, headers: def.headers || {} };
+}
+async function createMcpContext(session) {
+  const happyServer = await startHappyServer(session);
+  const servers = {
+    happy: {
+      url: happyServer.url,
+      toolNames: happyServer.toolNames,
+      stop: () => happyServer.stop()
+    }
+  };
+  const extraServersJson = process.env.HAPPY_EXTRA_MCP_SERVERS;
+  if (extraServersJson) {
+    try {
+      const extraServers = JSON.parse(extraServersJson);
+      for (const srv of extraServers) {
+        servers[srv.name] = {
+          url: srv.url,
+          toolNames: [],
+          // External MCP — tools discovered by agent, not whitelisted
+          headers: srv.headers,
+          stop: () => {
+          }
+          // No lifecycle management for external servers
+        };
+      }
+    } catch (e) {
+      console.warn("Failed to parse HAPPY_EXTRA_MCP_SERVERS:", e);
+    }
+  }
+  return {
+    configForClaude() {
+      const result = {};
+      for (const [name, def] of Object.entries(servers)) {
+        result[name] = adaptForClaude(def);
+      }
+      return result;
+    },
+    configForStdio() {
+      const result = {};
+      for (const [name, def] of Object.entries(servers)) {
+        result[name] = adaptForStdio(def);
+      }
+      return result;
+    },
+    configForHttp() {
+      const result = {};
+      for (const [name, def] of Object.entries(servers)) {
+        result[name] = adaptForHttp(def);
+      }
+      return result;
+    },
+    allowedToolNames() {
+      return Object.entries(servers).flatMap(
+        ([name, def]) => def.toolNames.map((tool) => `mcp__${name}__${tool}`)
+      );
+    },
+    normalizeToolName(rawName) {
+      for (const [name, def] of Object.entries(servers)) {
+        if (def.toolNames.includes(rawName)) {
+          return `mcp:${name}:${rawName}`;
+        }
+      }
+      return rawName;
+    },
+    stop() {
+      for (const def of Object.values(servers)) {
+        def.stop();
+      }
+    }
+  };
+}
+
+function detectGitWorktree(cwd) {
+  try {
+    const gitDir = node_child_process.execSync("git rev-parse --git-dir", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const gitCommonDir = node_child_process.execSync("git rev-parse --git-common-dir", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const absGitDir = path.resolve(cwd, gitDir);
+    const absCommonDir = path.resolve(cwd, gitCommonDir);
+    if (absGitDir === absCommonDir) {
+      return { isWorktree: false };
+    }
+    const basePath = path.dirname(absCommonDir);
+    const branchName = node_child_process.execSync("git rev-parse --abbrev-ref HEAD", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return {
+      isWorktree: true,
+      worktreeBasePath: basePath,
+      worktreeBranchName: branchName || void 0
+    };
+  } catch {
+    return { isWorktree: false };
+  }
+}
+
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    logger.logger.debug("Kill session request received");
+    void killThisHappy();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
+  });
+}
+
+exports.createMcpContext = createMcpContext;
+exports.detectGitWorktree = detectGitWorktree;
+exports.registerKillSessionHandler = registerKillSessionHandler;

package/dist/{run-BEflQaQ2.mjs → run-BFnSUK1o.mjs}

@@ -1,15 +1,15 @@
 import fs from 'fs/promises';
 import os from 'os';
 import * as tmp from 'tmp';
-import { A as ApiClient } from './api-Ew6xr81i.mjs';
-import { c as configuration, l as logger, p as packageJson, v as acquireDaemonLock, a as readSettings, i as isDebug, e as encodeBase64, x as writeDaemonState, m as readDaemonState, y as releaseDaemonLock, z as validateProfileForAgent, A as getProfileEnvironmentVariables } from './persistence-D9tMm6bj.mjs';
-import { authAndSetupMachineIfNeeded } from './auth-Q2STUNI-.mjs';
+import { A as ApiClient } from './api-BUCtd3cB.mjs';
+import { c as configuration, l as logger, p as packageJson, v as acquireDaemonLock, a as readSettings, i as isDebug, e as encodeBase64, x as writeDaemonState, m as readDaemonState, y as releaseDaemonLock, z as validateProfileForAgent, A as getProfileEnvironmentVariables } from './persistence-DbLMvLvk.mjs';
+import { authAndSetupMachineIfNeeded } from './auth-qM2eojWx.mjs';
 import { spawn, execSync, exec } from 'child_process';
-import { getEnvironmentInfo } from './doctor-DRnft_5-.mjs';
-import { s as spawnHappyCLI } from './spawnHappyCLI-DhUeycct.mjs';
-import { isDaemonRunningCurrentlyInstalledHappyVersion, stopDaemon, cleanupDaemonState } from './controlClient-DoS9JqQC.mjs';
-import { a as readCachedDeviceKey, d as deviceExec } from './deviceKeys-B4aqjnE6.mjs';
-import { P as PLIST_LABEL } from './install-DBg0xQ3g.mjs';
+import { getEnvironmentInfo } from './doctor-DDT2TXHH.mjs';
+import { s as spawnHappyCLI } from './spawnHappyCLI-Dt7fbmbk.mjs';
+import { isDaemonRunningCurrentlyInstalledHappyVersion, stopDaemon, cleanupDaemonState } from './controlClient-BzzTNSfl.mjs';
+import { a as readCachedDeviceKey, d as deviceExec } from './deviceKeys-CQyFFPtt.mjs';
+import { P as PLIST_LABEL } from './install-BOIcR_Wr.mjs';
 import fastify from 'fastify';
 import { createReadStream } from 'node:fs';
 import { stat } from 'node:fs/promises';
@@ -1851,6 +1851,8 @@ ${error.message}
             if (!skipForkSession) {
               args.push("--fork-session");
             }
+          } else if (resumeSessionId && options.agent === "cursor") {
+            args.push("--resume", resumeSessionId);
           }
           const happyProcess = spawnHappyCLI(args, {
             cwd: directory,

package/dist/{run-CiPWWhXt.cjs → run-C5StYRIB.cjs}

@@ -3,15 +3,15 @@
 var fs$1 = require('fs/promises');
 var os = require('os');
 var tmp = require('tmp');
-var api = require('./api-CIE4_cWd.cjs');
-var logger = require('./persistence-BcQmjobZ.cjs');
-var auth = require('./auth-G9fZpVJ2.cjs');
+var api = require('./api-B-PlVQY6.cjs');
+var logger = require('./persistence-D7zNFI-d.cjs');
+var auth = require('./auth-BqGkUXvq.cjs');
 var child_process = require('child_process');
-var doctor = require('./doctor-BJSuVRUZ.cjs');
-var spawnHappyCLI = require('./spawnHappyCLI-Cfu7C1uM.cjs');
-var controlClient = require('./controlClient-CEz_p1zc.cjs');
-var deviceKeys = require('./deviceKeys-DyUn0bEx.cjs');
-var install = require('./install-Tyhs6rUp.cjs');
+var doctor = require('./doctor-D4xWXiE7.cjs');
+var spawnHappyCLI = require('./spawnHappyCLI-C2uY9WV-.cjs');
+var controlClient = require('./controlClient-yTkpwcOq.cjs');
+var deviceKeys = require('./deviceKeys-CdW-HPnz.cjs');
+var install = require('./install-Jrs6YUu8.cjs');
 var fastify = require('fastify');
 var fs = require('node:fs');
 var promises = require('node:fs/promises');
@@ -1872,6 +1872,8 @@ ${error.message}
             if (!skipForkSession) {
               args.push("--fork-session");
             }
+          } else if (resumeSessionId && options.agent === "cursor") {
+            args.push("--resume", resumeSessionId);
           }
           const happyProcess = spawnHappyCLI.spawnHappyCLI(args, {
             cwd: directory,

package/dist/{runClaude-BVXsyCHb.cjs → runClaude-ChRp6f5G.cjs}

@@ -4,20 +4,20 @@ var os = require('node:os');
 var node_crypto = require('node:crypto');
 var fs$1 = require('node:fs');
 var promises = require('node:fs/promises');
-var api = require('./api-CIE4_cWd.cjs');
-var logger = require('./persistence-BcQmjobZ.cjs');
-var claudeLocal = require('./claudeLocal-f4uBLJaM.cjs');
+var api = require('./api-B-PlVQY6.cjs');
+var logger = require('./persistence-D7zNFI-d.cjs');
+var claudeLocal = require('./claudeLocal-HAXk0deK.cjs');
 var types = require('./types-DWeB7aqh.cjs');
 var path = require('node:path');
 var time = require('./time-Bj2HRkKH.cjs');
 var fs = require('fs/promises');
 var ink = require('ink');
-var downloadImage = require('./downloadImage-Cijmufpr.cjs');
+var downloadImage = require('./downloadImage-3A6zY5AX.cjs');
 var React = require('react');
 var node_child_process = require('node:child_process');
 var node_readline = require('node:readline');
 var node_url = require('node:url');
-var spawnHappyCLI = require('./spawnHappyCLI-Cfu7C1uM.cjs');
+var spawnHappyCLI = require('./spawnHappyCLI-C2uY9WV-.cjs');
 var projectPath = require('./projectPath-ChLhdOyt.cjs');
 require('axios');
 require('node:events');
@@ -28,13 +28,13 @@ require('crypto');
 require('@stablelib/base64');
 require('expo-server-sdk');
 require('chalk');
-var formatImageMessage = require('./formatImageMessage-BPK_Ivfe.cjs');
+var formatImageMessage = require('./formatImageMessage-bVFGFDJl.cjs');
 var node_util = require('node:util');
-var run = require('./run-CiPWWhXt.cjs');
-var doctor = require('./doctor-BJSuVRUZ.cjs');
-var controlClient = require('./controlClient-CEz_p1zc.cjs');
+var run = require('./run-C5StYRIB.cjs');
+var doctor = require('./doctor-D4xWXiE7.cjs');
+var controlClient = require('./controlClient-yTkpwcOq.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-MoLdSQxM.cjs');
 var node_http = require('node:http');
-var gitWorktree = require('./gitWorktree-C6jLoaMw.cjs');
 require('zod');
 require('./index-BeKrqPYR.cjs');
 require('@paralleldrive/cuid2');
@@ -42,29 +42,29 @@ require('child_process');
 require('util');
 require('path');
 require('node:module');
-require('./sessionKeyCache-BwFUGgMs.cjs');
+require('./sessionKeyCache-3Pme04yL.cjs');
 require('fs');
 require('./prompt-BTWDZZO0.cjs');
 require('./trimIdent-4gvk9Wk6.cjs');
 require('./common-CZvSRU4p.cjs');
-require('@modelcontextprotocol/sdk/server/mcp.js');
-require('@modelcontextprotocol/sdk/server/streamableHttp.js');
-require('@modelcontextprotocol/sdk/types.js');
-require('./deviceKeys-DyUn0bEx.cjs');
-require('./auth-G9fZpVJ2.cjs');
-require('qrcode-terminal');
-require('./browser-qDIIAL7S.cjs');
-require('open');
-require('./mcpToolSchemas-DK42yoZ_.cjs');
 require('url');
 require('os');
 require('tmp');
-require('./install-Tyhs6rUp.cjs');
+require('./auth-BqGkUXvq.cjs');
+require('qrcode-terminal');
+require('./browser-CY7VNU0C.cjs');
+require('open');
+require('./deviceKeys-CdW-HPnz.cjs');
+require('./install-Jrs6YUu8.cjs');
 require('fastify');
 require('fastify-type-provider-zod');
 require('./doctor-C08m5Z9f.cjs');
 require('ps-list');
 require('cross-spawn');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+require('@modelcontextprotocol/sdk/types.js');
+require('./mcpToolSchemas-DK42yoZ_.cjs');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 class Session {
@@ -732,7 +732,7 @@ class AbortError extends Error {
   }
 }
 
-const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('runClaude-BVXsyCHb.cjs', document.baseURI).href)));
+const __filename$1 = node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('runClaude-ChRp6f5G.cjs', document.baseURI).href)));
 const __dirname$1 = path.join(__filename$1, "..");
 function getGlobalClaudeVersion() {
   try {
@@ -3288,7 +3288,7 @@ function detectWorktreeMetadata(cwd) {
       worktreeBranchName: process.env.HAPPY_WORKTREE_BRANCH_NAME
     };
   }
-  const info = gitWorktree.detectGitWorktree(cwd);
+  const info = registerKillSessionHandler.detectGitWorktree(cwd);
   if (info.isWorktree) {
     return {
       isWorktree: true,
@@ -3302,7 +3302,7 @@ function detectWorktreeMetadata(cwd) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       const subDir = path.join(cwd, entry.name);
-      const sub = gitWorktree.detectGitWorktree(subDir);
+      const sub = registerKillSessionHandler.detectGitWorktree(subDir);
       if (sub.isWorktree && sub.worktreeBasePath && sub.worktreeBranchName) {
         repos.push({
           path: subDir,
@@ -3464,7 +3464,7 @@ async function runClaude(credentials, options = {}) {
     }));
     logger.logger.debug(`[START] Injected ${injectedMemoryIds.length} memories into session`);
   }
-  const mcp = await downloadImage.createMcpContext(session);
+  const mcp = await registerKillSessionHandler.createMcpContext(session);
   logger.logger.debug(`[START] MCP context created`);
   let currentSession = null;
   const shouldBackfill = ["1", "true", "yes"].includes(String(process.env.HAPPY_CLAUDE_BACKFILL).toLowerCase());
@@ -3722,7 +3722,7 @@ async function runClaude(credentials, options = {}) {
     logger.logger.debug("[START] Unhandled rejection:", reason);
     cleanup();
   });
-  downloadImage.registerKillSessionHandler(session.rpcHandlerManager, cleanup);
+  registerKillSessionHandler.registerKillSessionHandler(session.rpcHandlerManager, cleanup);
   const exitCode = await loop({
     path: workingDirectory,
     model: options.model,