very-happy-cli 0.2.159 → 0.2.160

package/dist/{index-BEOMECtE.cjs → index-B6pAdvJx.cjs}

@@ -1,57 +1,87 @@
 'use strict';
 
-var AcpBackend = require('./AcpBackend-DUYFlyfN.cjs');
-var persistence = require('./limits-BH5CV5vR.cjs');
-var AcpSessionManager = require('./AcpSessionManager-Bdv8LWXh.cjs');
-var index$1 = require('./index-rH3DrQ5B.cjs');
-var piRuntime = require('./piRuntime-NtF0YqjH.cjs');
+var AcpBackend = require('./AcpBackend-Bm2rdke8.cjs');
+var logger = require('./logger-CS0mw3fa.cjs');
+var AcpSessionManager = require('./AcpSessionManager-BAY1Pggx.cjs');
+var index = require('./index-DA7yINuk.cjs');
+var agentAttachments = require('./agentAttachments-Dbw8iMCZ.cjs');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+var attachmentContent = require('./attachmentContent-DpiTJZb4.cjs');
+var piRuntime = require('./piRuntime-C_H7MJCM.cjs');
 var node_crypto = require('node:crypto');
 var path = require('node:path');
-var index = require('./types-BbvK1Tr_.cjs');
-var terminalTitleSuggest = require('./terminalTitleSuggest-Dji8I0Jy.cjs');
+var api = require('./api-CgundNNX.cjs');
+var registerKillSessionHandler = require('./registerKillSessionHandler-DZeLXWcB.cjs');
+var deterministicJson = require('./deterministicJson-C5CYTVpm.cjs');
+var persistence = require('./persistence-yKTH3-5X.cjs');
+var machineMetadata = require('./machineMetadata-DyDbODYd.cjs');
+var createSessionMetadata = require('./createSessionMetadata-BJxEnM-o.cjs');
+var setupOfflineReconnection = require('./setupOfflineReconnection-ByElY60m.cjs');
+var controlClient = require('./controlClient-Bcwv3D21.cjs');
+var authRelay = require('./authRelay-BdYkC1Po.cjs');
+var streamRelay = require('./streamRelay-BiKw59Cc.cjs');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var BasePermissionHandler = require('./BasePermissionHandler-CFHAxumV.cjs');
+var titleGenerator = require('./titleGenerator-ChzMJsyg.cjs');
+var sessionModeFile = require('./sessionModeFile-RSm0NQkH.cjs');
+var editPaths = require('./editPaths-Bqp4OFPw.cjs');
 require('node:child_process');
 require('@agentclientprotocol/sdk');
-require('zod');
-require('@paralleldrive/cuid2');
-require('node:fs/promises');
-require('node:fs');
-require('tweetnacl');
+require('./time-DCuTyook.cjs');
+require('./contentLogMetadata-ZSFk_NjQ.cjs');
+require('./package-BwMrPwqH.cjs');
 require('chalk');
 require('node:util');
+require('node:fs');
+require('@paralleldrive/cuid2');
+require('zod');
 require('node:os');
-require('cross-spawn');
-require('node:readline');
-require('./agentGuidance-BRDN1NoZ.cjs');
+require('node:fs/promises');
+require('./attachmentLimits-CzVrqgLR.cjs');
+require('./resources-JDPugcDq.cjs');
 require('axios');
-require('socket.io-client');
-require('fs/promises');
-require('ink');
-require('react');
-require('@anthropic-ai/claude-agent-sdk');
 require('node:events');
+require('socket.io-client');
+require('./limits-C-a7gr04.cjs');
+require('./lidState-BeDfxxEX.cjs');
 require('os');
 require('child_process');
-require('fs');
-require('path');
-require('@anthropic-ai/sandbox-runtime');
-require('expo-server-sdk');
+require('./registerCommonHandlers-DskirN-_.cjs');
+require('util');
+require('fs/promises');
 require('crypto');
-require('ps-list');
-require('tmp');
-require('open');
-require('fastify');
-require('fastify-type-provider-zod');
-require('node:module');
+require('path');
+require('cross-spawn');
+require('./sync-DccIKZ5_.cjs');
+require('./backgroundTaskActivity-CBvUdj39.cjs');
+require('tweetnacl');
+require('./types-CRS-srZK.cjs');
+require('./client-3Ac-O4pw.cjs');
+require('./context-DsDr6E2t.cjs');
+require('./sessionOps-Dn8z85h_.cjs');
+require('./tools-Be3AoAwu.cjs');
+require('./tools-DQj0AeLk.cjs');
+require('./client-BPNbmtvO.cjs');
+require('./peerTools-BvKtHXj8.cjs');
+require('./ids-B6ZC0HGt.cjs');
+require('./remoteSessionClient-B0LraSB9.cjs');
 require('@modelcontextprotocol/sdk/server/mcp.js');
 require('node:http');
 require('@modelcontextprotocol/sdk/server/streamableHttp.js');
-require('http');
-require('util');
-require('inquirer');
-require('node:url');
-require('node:readline/promises');
-require('node-pty');
+require('./assistantTools-BTqPnlFl.cjs');
+require('./terminals-B_bfC9c2.cjs');
+require('./terminalTitleSuggest-DhvRFX3H.cjs');
+require('./tmuxSocket-D-Xt6Vn-.cjs');
+require('./bootstrap-B5G1TijC.cjs');
+require('./agentGuidance-B5NATuFa.cjs');
+require('./trimIdent-4gvk9Wk6.cjs');
+require('./previewPath-B0rBdhy1.cjs');
+require('./detectCLI-DR9ZaN6B.cjs');
+require('fs');
+require('./localHappyAgentAuth-D6rFhaoc.cjs');
 require('url');
+require('node:module');
+require('./oneShotPrompts-CL0dip9C.cjs');
 
 function createAcpBackend(options) {
   const backendOptions = {
@@ -555,7 +585,7 @@ function resolveRequestedLegacyModelCode(models, requested) {
   }
   return null;
 }
-class GenericAcpPermissionHandler extends index$1.BasePermissionHandler {
+class GenericAcpPermissionHandler extends BasePermissionHandler.BasePermissionHandler {
   logPrefix;
   constructor(session, agentName) {
     super(session);
@@ -573,7 +603,7 @@ class GenericAcpPermissionHandler extends index$1.BasePermissionHandler {
         input
       });
       this.addPendingRequestToState(toolCallId, toolName, input);
-      persistence.logger.debug(`${this.logPrefix} Permission request sent for tool: ${toolName} (${toolCallId})`);
+      logger.logger.debug(`${this.logPrefix} Permission request sent for tool: ${toolName} (${toolCallId})`);
     });
   }
 }
@@ -589,33 +619,33 @@ function resolveSessionFlavor(agentName) {
 async function runAcp(opts) {
   const verbose = opts.verbose === true;
   const sessionTag = node_crypto.randomUUID();
-  index.connectionState.setBackend(opts.agentName);
-  const api = await index.ApiClient.create(opts.credentials);
+  api.connectionState.setBackend(opts.agentName);
+  const api$1 = await api.ApiClient.create(opts.credentials);
   const settings = await persistence.readSettings();
   if (!settings?.machineId) {
     throw new Error("No machine ID found in settings");
   }
-  await api.getOrCreateMachine({
+  await api$1.getOrCreateMachine({
     machineId: settings.machineId,
-    metadata: index$1.initialMachineMetadata
+    metadata: machineMetadata.getInitialMachineMetadata()
   });
-  const { state, metadata } = index$1.createSessionMetadata({
+  const { state, metadata } = createSessionMetadata.createSessionMetadata({
     flavor: resolveSessionFlavor(opts.agentName),
     ...process.env.VH_TEAM_OPERATION_ID ? { teamOperationId: process.env.VH_TEAM_OPERATION_ID } : {},
     machineId: settings.machineId,
     startedBy: opts.startedBy,
     sandbox: settings.sandboxConfig,
-    capabilities: [persistence.PROMPT_QUEUE_CAPABILITY]
+    capabilities: [index.PROMPT_QUEUE_CAPABILITY]
   });
   metadata.attachmentKinds = [];
-  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  const response = await api$1.getOrCreateSession({ tag: sessionTag, metadata, state });
   if (response) {
     logAcp("muted", `Happy Session ID: ${response.id}`);
   }
   let session;
   let permissionHandler;
-  const { session: initialSession, reconnectionHandle } = index$1.setupOfflineReconnection({
-    api,
+  const { session: initialSession, reconnectionHandle } = setupOfflineReconnection.setupOfflineReconnection({
+    api: api$1,
     sessionTag,
     metadata,
     state,
@@ -631,25 +661,25 @@ async function runAcp(opts) {
   session = initialSession;
   if (response) {
     try {
-      await persistence.notifyDaemonSessionStarted(response.id, metadata, {
-        encryptionKey: persistence.encodeBase64(response.encryptionKey),
+      await controlClient.notifyDaemonSessionStarted(response.id, metadata, {
+        encryptionKey: authRelay.encodeBase64(response.encryptionKey),
         encryptionVariant: response.encryptionVariant,
         seq: response.seq,
         metadataVersion: response.metadataVersion,
         agentStateVersion: response.agentStateVersion
       });
     } catch (error) {
-      persistence.logger.debug("[acp] Failed to report session to daemon:", error);
+      logger.logger.debug("[acp] Failed to report session to daemon:", error);
     }
   }
   permissionHandler = new GenericAcpPermissionHandler(session, opts.agentName);
   permissionHandler.reset("Previous CLI process exited before responding");
   const streamingEnabled = process.env.HAPPY_SESSION_STREAM_DISABLED !== "1";
-  const streamRelay = new index$1.StreamRelay({
+  const streamRelay$1 = new streamRelay.StreamRelay({
     send: (frame) => session.sendStreamFrame(frame)
   });
-  const sessionManager = new AcpSessionManager.AcpSessionManager(streamingEnabled ? { stream: streamRelay } : {});
-  const messageQueue = new index$1.MessageQueue2((mode) => index$1.hashObject(mode));
+  const sessionManager = new AcpSessionManager.AcpSessionManager(streamingEnabled ? { stream: streamRelay$1 } : {});
+  const messageQueue = new registerKillSessionHandler.MessageQueue2((mode) => deterministicJson.hashObject(mode));
   function attachPromptQueueDrain(client) {
     const drain = client.attachPromptQueueDrain({
       isIdle: () => messageQueue.size() === 0 && messageQueue.isWaiting()
@@ -677,18 +707,18 @@ async function runAcp(opts) {
       return true;
     }
     try {
-      index$1.writeSessionModeFile(session.sessionId, mode);
+      sessionModeFile.writeSessionModeFile(session.sessionId, mode);
     } catch (error) {
-      persistence.logger.debug(`[${opts.agentName}] Failed to write session mode file:`, error);
+      logger.logger.debug(`[${opts.agentName}] Failed to write session mode file:`, error);
       return false;
     }
     fileBackedPermissionMode = mode;
     session.updateMetadata((currentMetadata) => ({ ...currentMetadata, permissionMode: mode }));
-    persistence.logger.debug(`[${opts.agentName}] Published file-backed permission mode: ${mode}`);
+    logger.logger.debug(`[${opts.agentName}] Published file-backed permission mode: ${mode}`);
     return true;
   };
   const isAssistantVariant = process.env.HAPPY_SESSION_VARIANT === "assistant";
-  const happyServer = await index$1.startHappyServer(session, {
+  const happyServer = await deterministicJson.startHappyServer(session, {
     assistant: isAssistantVariant,
     ...opts.agentName === "pi" ? { onContextUsage: (contextUsage) => {
       session.updateAgentState((state2) => ({ ...state2, contextUsage }));
@@ -697,7 +727,7 @@ async function runAcp(opts) {
   if (opts.agentName === "pi") session.updateAgentState((state2) => ({ ...state2, contextUsage: null }));
   const mcpServers = {
     happy: {
-      command: path.join(terminalTitleSuggest.projectPath(), "bin", "very-happy-mcp.mjs"),
+      command: path.join(projectPath.projectPath(), "bin", "very-happy-mcp.mjs"),
       args: ["--url", happyServer.url]
     }
   };
@@ -756,7 +786,7 @@ async function runAcp(opts) {
   });
   const stopRunnerFromBackendStatus = (status, detail) => {
     const reason = detail ? `${opts.agentName} backend ${status}: ${detail}` : `${opts.agentName} backend ${status}`;
-    persistence.logger.debug(`[${opts.agentName}] ${reason}; stopping ACP runner`);
+    logger.logger.debug(`[${opts.agentName}] ${reason}; stopping ACP runner`);
     shouldExit = true;
     messageQueue.close();
     clearPendingTurn(new Error(reason));
@@ -778,9 +808,9 @@ async function runAcp(opts) {
       return;
     }
     if (permissionModeIsFileBacked()) {
-      const mode = index$1.normalizeAcpPermissionMode(requestedMode);
+      const mode = sessionModeFile.normalizeAcpPermissionMode(requestedMode);
       if (!mode) {
-        persistence.logger.debug(`[${opts.agentName}] Ignoring unknown file-backed permission mode request: ${requestedMode}`);
+        logger.logger.debug(`[${opts.agentName}] Ignoring unknown file-backed permission mode request: ${requestedMode}`);
         return;
       }
       publishFileBackedPermissionMode(mode);
@@ -789,7 +819,7 @@ async function runAcp(opts) {
     if (modeSelector) {
       const resolved = resolveRequestedCode(modeSelector.options, requestedMode);
       if (!resolved) {
-        persistence.logger.debug(`[${opts.agentName}] Ignoring unknown ACP permission mode request: ${requestedMode}`);
+        logger.logger.debug(`[${opts.agentName}] Ignoring unknown ACP permission mode request: ${requestedMode}`);
         return;
       }
       if (resolved === modeSelector.currentCode) {
@@ -806,7 +836,7 @@ async function runAcp(opts) {
     }
     const resolvedLegacyMode = resolveRequestedLegacyModeCode(legacyModes, requestedMode);
     if (!resolvedLegacyMode) {
-      persistence.logger.debug(`[${opts.agentName}] Ignoring unknown ACP legacy mode request: ${requestedMode}`);
+      logger.logger.debug(`[${opts.agentName}] Ignoring unknown ACP legacy mode request: ${requestedMode}`);
       return;
     }
     if (resolvedLegacyMode === legacyModes.currentModeId) {
@@ -870,7 +900,7 @@ async function runAcp(opts) {
     if (modelSelector) {
       const resolved = resolveRequestedCode(modelSelector.options, requestedModel);
       if (!resolved) {
-        persistence.logger.debug(`[${opts.agentName}] Ignoring unknown ACP model request: ${requestedModel}`);
+        logger.logger.debug(`[${opts.agentName}] Ignoring unknown ACP model request: ${requestedModel}`);
         return false;
       }
       if (resolved === modelSelector.currentCode) {
@@ -887,7 +917,7 @@ async function runAcp(opts) {
     }
     const resolvedLegacyModel = resolveRequestedLegacyModelCode(legacyModels, requestedModel);
     if (!resolvedLegacyModel) {
-      persistence.logger.debug(`[${opts.agentName}] Ignoring unknown ACP legacy model request: ${requestedModel}`);
+      logger.logger.debug(`[${opts.agentName}] Ignoring unknown ACP legacy model request: ${requestedModel}`);
       return false;
     }
     if (resolvedLegacyModel === legacyModels.currentModelId) {
@@ -907,7 +937,7 @@ async function runAcp(opts) {
     if (modelSelector) return resolveRequestedCode(modelSelector.options, requested) === modelSelector.currentCode;
     return !!legacyModels && resolveRequestedLegacyModelCode(legacyModels, requested) === legacyModels.currentModelId;
   };
-  const editThrottle = new index$1.EditReportThrottle();
+  const editThrottle = new editPaths.EditReportThrottle();
   const onBackendMessage = (msg) => {
     if (verbose) {
       logAcp("muted", `Outgoing raw backend message from ${opts.agentName}: ${formatUnknownForConsole(msg, ACP_RAW_PREVIEW_CHARS)}`);
@@ -1041,15 +1071,15 @@ async function runAcp(opts) {
       session.sendAgentUsageSnapshot(resolveSessionFlavor(opts.agentName), msg);
     }
     if (msg.type === "tool-call") {
-      for (const edit of editThrottle.take(index$1.extractAcpEditPaths(msg.toolName, msg.args))) {
-        persistence.reportSessionEditToDaemon({ sessionId: session.sessionId, path: edit.path, tool: edit.tool, cwd: process.cwd() });
+      for (const edit of editThrottle.take(editPaths.extractAcpEditPaths(msg.toolName, msg.args))) {
+        controlClient.reportSessionEditToDaemon({ sessionId: session.sessionId, path: edit.path, tool: edit.tool, cwd: process.cwd() });
       }
     }
     sendEnvelopes(sessionManager.mapMessage(msg));
   };
   backend.onMessage(onBackendMessage);
-  const titleGenerator = new index$1.TitleGenerator(session);
-  index$1.registerAgentAttachmentDownloads(session);
+  const titleGenerator$1 = new titleGenerator.TitleGenerator(session);
+  agentAttachments.registerAgentAttachmentDownloads(session);
   let userMessageDelivery = Promise.resolve();
   session.onUserMessage((message) => {
     const downloads = session.drainAttachmentsForUserMessage();
@@ -1058,14 +1088,14 @@ async function runAcp(opts) {
       if (!message.content.text && !attachments?.length) {
         return;
       }
-      titleGenerator.maybeGenerate(message.content.text);
+      titleGenerator$1.maybeGenerate(message.content.text);
       if (typeof message.meta?.permissionMode === "string") {
         currentPermissionMode = message.meta.permissionMode;
-        persistence.logger.debug(`[${opts.agentName}] Requested ACP permission mode: ${currentPermissionMode}`);
+        logger.logger.debug(`[${opts.agentName}] Requested ACP permission mode: ${currentPermissionMode}`);
       }
       if (message.meta && Object.prototype.hasOwnProperty.call(message.meta, "model")) {
         currentModel = message.meta.model ?? null;
-        persistence.logger.debug(`[${opts.agentName}] Requested ACP model: ${currentModel ?? "null"}`);
+        logger.logger.debug(`[${opts.agentName}] Requested ACP model: ${currentModel ?? "null"}`);
       }
       if (message.meta && Object.prototype.hasOwnProperty.call(message.meta, "effort")) {
         currentEffort = message.meta.effort ?? null;
@@ -1076,7 +1106,7 @@ async function runAcp(opts) {
         effort: currentEffort
       }, attachments, message.localKey);
     }).catch(() => {
-      persistence.logger.warn("[ACP] Failed to prepare user attachments");
+      logger.logger.warn("[ACP] Failed to prepare user attachments");
       session.sendSessionEvent({ type: "message", message: "Could not prepare this message. Please send it again." });
     });
   });
@@ -1093,7 +1123,7 @@ async function runAcp(opts) {
       permissionHandler.reset();
       abortController.abort();
     } catch (error) {
-      persistence.logger.debug(`[${opts.agentName}] Abort failed:`, error);
+      logger.logger.debug(`[${opts.agentName}] Abort failed:`, error);
     } finally {
       abortController = new AbortController();
     }
@@ -1105,7 +1135,7 @@ async function runAcp(opts) {
       if (!fileBackedModeActive) {
         throw new Error(`${opts.agentName} does not support live permission mode changes`);
       }
-      const mode = typeof request?.mode === "string" ? index$1.normalizeAcpPermissionMode(request.mode) : null;
+      const mode = typeof request?.mode === "string" ? sessionModeFile.normalizeAcpPermissionMode(request.mode) : null;
       if (!mode) {
         throw new Error("Invalid permission mode");
       }
@@ -1115,7 +1145,7 @@ async function runAcp(opts) {
       return { mode };
     }
   );
-  const disposeTermination = index$1.registerKillSessionHandler(session.rpcHandlerManager, async () => {
+  const disposeTermination = registerKillSessionHandler.registerKillSessionHandler(session.rpcHandlerManager, async () => {
     shouldExit = true;
     messageQueue.close();
     clearPendingTurn(new Error("Session terminated"));
@@ -1131,7 +1161,7 @@ async function runAcp(opts) {
     }
     session.updateMetadata((current) => ({
       ...current,
-      attachmentKinds: opts.agentName === "pi" && backend.supportsImageAttachments ? [...index$1.CLAUDE_ATTACHMENT_KINDS] : []
+      attachmentKinds: opts.agentName === "pi" && backend.supportsImageAttachments ? [...attachmentContent.CLAUDE_ATTACHMENT_KINDS] : []
     }));
     if (permissionModeIsFileBacked()) {
       fileBackedModeActive = true;
@@ -1181,17 +1211,17 @@ async function runAcp(opts) {
         }
         const prompt = todoDiscoverySent ? batch.message : `${batch.message}
 
-${persistence.BUILTIN_TODO_DISCOVERY}`;
+${index.BUILTIN_TODO_DISCOVERY}`;
         const attachments = batch.attachments ?? [];
-        const staged = attachments.length ? await index$1.stageClaudeAttachments(attachments, {
-          happyHomeDir: persistence.configuration.happyHomeDir,
+        const staged = attachments.length ? await attachmentContent.stageClaudeAttachments(attachments, {
+          happyHomeDir: configuration.configuration.happyHomeDir,
           sessionId: session.sessionId
         }) : [];
-        await backend.sendPrompt(acpSessionId, index$1.appendStagedAttachmentsToPrompt(prompt, staged), attachments);
+        await backend.sendPrompt(acpSessionId, attachmentContent.appendStagedAttachmentsToPrompt(prompt, staged), attachments);
         todoDiscoverySent = true;
         await turnEnded;
         sendEnvelopes(sessionManager.endTurn(turnCancelled ? "cancelled" : "completed"));
-        streamRelay.endTurn();
+        streamRelay$1.endTurn();
         setThinking(false);
         session.sendSessionEvent({ type: "ready" });
         if (verbose) {
@@ -1200,7 +1230,7 @@ ${persistence.BUILTIN_TODO_DISCOVERY}`;
       } catch (error) {
         session.sendSessionEvent({ type: "message", message: "The agent could not process this message or its attachments. Please check the agent and try again." });
         sendEnvelopes(sessionManager.endTurn("failed"));
-        streamRelay.endTurn();
+        streamRelay$1.endTurn();
         setThinking(false);
         session.sendSessionEvent({ type: "ready" });
         logAcp("error", `Prompt error from ${opts.agentName}: ${error instanceof Error ? error.message : String(error)}`);
@@ -1212,28 +1242,28 @@ ${persistence.BUILTIN_TODO_DISCOVERY}`;
     disposeTermination?.();
     setThinking(false);
     clearInterval(keepAliveInterval);
-    streamRelay.endTurn();
-    streamRelay.dispose();
+    streamRelay$1.endTurn();
+    streamRelay$1.dispose();
     reconnectionHandle?.cancel();
     clearPendingTurn(new Error("ACP runner shutting down"));
     try {
       permissionHandler.reset();
     } catch (error) {
-      persistence.logger.debug(`[${opts.agentName}] Failed to reset permission handler:`, error);
+      logger.logger.debug(`[${opts.agentName}] Failed to reset permission handler:`, error);
     }
     backend.offMessage?.(onBackendMessage);
     await backend.dispose();
     if (fileBackedPermissionMode) {
       try {
-        index$1.removeSessionModeFile(session.sessionId);
+        sessionModeFile.removeSessionModeFile(session.sessionId);
       } catch (error) {
-        persistence.logger.debug(`[${opts.agentName}] Failed to remove session mode file:`, error);
+        logger.logger.debug(`[${opts.agentName}] Failed to remove session mode file:`, error);
       }
     }
     try {
       happyServer.stop();
     } catch (error) {
-      persistence.logger.debug(`[${opts.agentName}] Failed to stop Happy MCP server:`, error);
+      logger.logger.debug(`[${opts.agentName}] Failed to stop Happy MCP server:`, error);
     }
     try {
       session.closePromptQueueDrain();
@@ -1248,7 +1278,7 @@ ${persistence.BUILTIN_TODO_DISCOVERY}`;
       await session.flush();
       await session.close();
     } catch (error) {
-      persistence.logger.debug(`[${opts.agentName}] Session close failed:`, error);
+      logger.logger.debug(`[${opts.agentName}] Session close failed:`, error);
     }
   }
 }

package/dist/index-Bu5Zi_a9.cjs

@@ -0,0 +1,182 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var os = require('node:os');
+var logger = require('./logger-CS0mw3fa.cjs');
+var persistence = require('./persistence-yKTH3-5X.cjs');
+var loginShellEnv = require('./loginShellEnv-BkuYtExZ.cjs');
+require('chalk');
+require('node:util');
+require('./configuration-BSYpcPwE.cjs');
+require('node:path');
+require('./package-BwMrPwqH.cjs');
+require('node:fs/promises');
+require('zod');
+require('./authRelay-BdYkC1Po.cjs');
+require('node:crypto');
+require('tweetnacl');
+require('node:child_process');
+
+const AGENT_HOME_CACHE_MS = 6e4;
+const AGENT_HOME_FAILURE_CACHE_MS = 5 * 6e4;
+const AGENT_HOME_MAX_STALE_MS = 10 * 6e4;
+function decideShellProbe(entry, now, allowStale) {
+  if (!entry) return "await-probe";
+  const age = now - entry.probedAt;
+  if (age < entry.ttlMs) return "use-cached";
+  if (allowStale && age < AGENT_HOME_MAX_STALE_MS) return "use-stale-and-revalidate";
+  return "await-probe";
+}
+let shellProbe = null;
+let shellProbeInFlight = null;
+let last = null;
+let originalDaemonEnv = null;
+function snapshotDaemonEnv() {
+  if (!originalDaemonEnv) {
+    originalDaemonEnv = {};
+    for (const name of loginShellEnv.AGENT_HOME_ENV_NAMES) originalDaemonEnv[name] = process.env[name];
+  }
+  return originalDaemonEnv;
+}
+function probeShell(now) {
+  if (!shellProbeInFlight) {
+    const run = loginShellEnv.probeLoginShellEnv(loginShellEnv.AGENT_HOME_ENV_NAMES).then((env) => {
+      const entry = { env, probedAt: now, ttlMs: env ? AGENT_HOME_CACHE_MS : AGENT_HOME_FAILURE_CACHE_MS };
+      shellProbe = entry;
+      return entry;
+    });
+    shellProbeInFlight = run;
+    void run.finally(() => {
+      if (shellProbeInFlight === run) shellProbeInFlight = null;
+    }).catch(() => {
+    });
+  }
+  return shellProbeInFlight;
+}
+async function loginShellEnvFor(now, allowStale) {
+  const decision = decideShellProbe(shellProbe, now, allowStale);
+  if (decision === "await-probe") return (await probeShell(now)).env;
+  if (decision === "use-stale-and-revalidate") {
+    probeShell(now).catch((error) => logger.logger.debug("[AGENT HOME] background login-shell probe failed", error));
+  }
+  return shellProbe.env;
+}
+async function refreshAgentHomes(now = Date.now(), opts = {}) {
+  let input;
+  let homes;
+  try {
+    const loginShellEnv$1 = await loginShellEnvFor(now, opts.allowStale === true);
+    const settings = await persistence.readSettings();
+    input = {
+      settings: { claudeConfigDir: settings.claudeConfigDir, codexHome: settings.codexHome },
+      daemonEnv: snapshotDaemonEnv(),
+      loginShellEnv: loginShellEnv$1,
+      homeDir: os.homedir()
+    };
+    homes = loginShellEnv.resolveAgentHomes(input);
+  } catch (error) {
+    logger.logger.debug("[AGENT HOME] resolve failed, falling back", error);
+    if (last) return last.homes;
+    return loginShellEnv.resolveAgentHomes({ settings: {}, daemonEnv: snapshotDaemonEnv(), loginShellEnv: null, homeDir: os.homedir() });
+  }
+  const previous = last?.homes;
+  last = { input, homes };
+  applyAgentHomesToProcessEnv(homes);
+  if (!previous || previous.claudeConfigDir.path !== homes.claudeConfigDir.path || previous.codexHome.path !== homes.codexHome.path) {
+    logger.logger.debug(`[AGENT HOME] Claude config dir: ${loginShellEnv.describeAgentHome(homes.claudeConfigDir)}; Codex home: ${loginShellEnv.describeAgentHome(homes.codexHome)}`);
+  }
+  return homes;
+}
+function currentAgentHomes() {
+  return last?.homes ?? null;
+}
+function resetAgentHomesCache() {
+  shellProbe = null;
+  shellProbeInFlight = null;
+  last = null;
+  originalDaemonEnv = null;
+}
+function applyAgentHomesToProcessEnv(homes) {
+  const overlay = loginShellEnv.agentHomeEnv(homes);
+  for (const name of loginShellEnv.AGENT_HOME_ENV_NAMES) {
+    const next = overlay[name];
+    if (next === void 0) {
+      const original = snapshotDaemonEnv()[name];
+      if (original === void 0) delete process.env[name];
+      else process.env[name] = original;
+    } else if (process.env[name] !== next) {
+      process.env[name] = next;
+    }
+  }
+}
+function listDirSafe(path) {
+  try {
+    return node_fs.readdirSync(path);
+  } catch {
+    return [];
+  }
+}
+function fileSizeSafe(path) {
+  try {
+    const st = node_fs.statSync(path);
+    return st.isFile() ? st.size : null;
+  } catch {
+    return null;
+  }
+}
+function locateClaudeConversation(workingDirectory, claudeSessionId) {
+  const entry = last;
+  if (!entry) {
+    const input = { settings: {}, daemonEnv: process.env, loginShellEnv: null, homeDir: os.homedir() };
+    return loginShellEnv.findClaudeConversation(claudeSessionId, workingDirectory, loginShellEnv.agentHomeCandidates("claude", input), fileSizeSafe);
+  }
+  return loginShellEnv.findClaudeConversation(claudeSessionId, workingDirectory, loginShellEnv.agentHomeCandidates("claude", entry.input, entry.homes), fileSizeSafe);
+}
+function locateCodexThread(codexThreadId) {
+  const entry = last;
+  const input = entry?.input ?? { settings: {}, daemonEnv: process.env, loginShellEnv: null, homeDir: os.homedir() };
+  return loginShellEnv.findCodexThread(codexThreadId, loginShellEnv.agentHomeCandidates("codex", input, entry?.homes), listDirSafe);
+}
+function agentHomeSpawnEnv(input) {
+  const env = {};
+  if (input.claudeSessionId) {
+    const hit = locateClaudeConversation(input.workingDirectory, input.claudeSessionId);
+    if (hit && !hit.resolved) {
+      env[loginShellEnv.CLAUDE_CONFIG_DIR_ENV] = hit.home;
+      logger.logger.debug(`[AGENT HOME] Claude conversation ${input.claudeSessionId} found under ${hit.home}; overriding ${loginShellEnv.CLAUDE_CONFIG_DIR_ENV} for this spawn`);
+    }
+  }
+  if (input.codexThreadId) {
+    const hit = locateCodexThread(input.codexThreadId);
+    if (hit && !hit.resolved) {
+      env[loginShellEnv.CODEX_HOME_ENV] = hit.home;
+      logger.logger.debug(`[AGENT HOME] Codex thread ${input.codexThreadId} found under ${hit.home}; overriding ${loginShellEnv.CODEX_HOME_ENV} for this spawn`);
+    }
+  }
+  return env;
+}
+
+exports.AGENT_HOME_ENV_NAMES = loginShellEnv.AGENT_HOME_ENV_NAMES;
+exports.CLAUDE_CONFIG_DIR_ENV = loginShellEnv.CLAUDE_CONFIG_DIR_ENV;
+exports.CODEX_HOME_ENV = loginShellEnv.CODEX_HOME_ENV;
+exports.agentHomeCandidates = loginShellEnv.agentHomeCandidates;
+exports.agentHomeEnv = loginShellEnv.agentHomeEnv;
+exports.claudeConversationPath = loginShellEnv.claudeConversationPath;
+exports.claudeProjectDirName = loginShellEnv.claudeProjectDirName;
+exports.codexRolloutFileMatches = loginShellEnv.codexRolloutFileMatches;
+exports.describeAgentHome = loginShellEnv.describeAgentHome;
+exports.expandHomePath = loginShellEnv.expandHomePath;
+exports.findClaudeConversation = loginShellEnv.findClaudeConversation;
+exports.findCodexThread = loginShellEnv.findCodexThread;
+exports.probeLoginShellEnv = loginShellEnv.probeLoginShellEnv;
+exports.resolveAgentHomes = loginShellEnv.resolveAgentHomes;
+exports.AGENT_HOME_CACHE_MS = AGENT_HOME_CACHE_MS;
+exports.AGENT_HOME_FAILURE_CACHE_MS = AGENT_HOME_FAILURE_CACHE_MS;
+exports.AGENT_HOME_MAX_STALE_MS = AGENT_HOME_MAX_STALE_MS;
+exports.agentHomeSpawnEnv = agentHomeSpawnEnv;
+exports.currentAgentHomes = currentAgentHomes;
+exports.decideShellProbe = decideShellProbe;
+exports.locateClaudeConversation = locateClaudeConversation;
+exports.locateCodexThread = locateCodexThread;
+exports.refreshAgentHomes = refreshAgentHomes;
+exports.resetAgentHomesCache = resetAgentHomesCache;