very-happy-cli 0.2.143 → 0.2.144

package/dist/{types-6__wqmmP.cjs → types-DZ5c-9f3.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 var axios = require('axios');
-var persistence = require('./limits-B3oVgqBJ.cjs');
+var persistence = require('./limits-C_Sklt--.cjs');
 var node_events = require('node:events');
 var socket_ioClient = require('socket.io-client');
 var z = require('zod');
@@ -4971,17 +4971,315 @@ function scrubTmuxClientEnv(env) {
   return env;
 }
 
-function getClaudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || path$1.join(os$1.homedir(), ".claude");
+const CLAUDE_CONFIG_DIR_ENV = "CLAUDE_CONFIG_DIR";
+const CODEX_HOME_ENV = "CODEX_HOME";
+const AGENT_HOME_ENV_NAMES = [CLAUDE_CONFIG_DIR_ENV, CODEX_HOME_ENV];
+function expandHomePath(value, homeDir) {
+  const trimmed = value.trim();
+  if (trimmed === "~") return homeDir;
+  if (trimmed.startsWith("~/")) return path$1.join(homeDir, trimmed.slice(2));
+  return path$1.isAbsolute(trimmed) ? trimmed : path$1.resolve(homeDir, trimmed);
+}
+function nonEmpty(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function pick(envName, settingValue, input, defaultRelative) {
+  const fromSettings = nonEmpty(settingValue);
+  if (fromSettings) return { path: expandHomePath(fromSettings, input.homeDir), source: "settings" };
+  const fromShell = nonEmpty(input.loginShellEnv?.[envName]);
+  if (fromShell) return { path: expandHomePath(fromShell, input.homeDir), source: "login-shell" };
+  const fromDaemon = nonEmpty(input.daemonEnv[envName]);
+  if (fromDaemon) return { path: expandHomePath(fromDaemon, input.homeDir), source: "daemon-env" };
+  return { path: path$1.join(input.homeDir, defaultRelative), source: "default" };
+}
+function resolveAgentHomes(input) {
+  return {
+    claudeConfigDir: pick(CLAUDE_CONFIG_DIR_ENV, input.settings.claudeConfigDir, input, ".claude"),
+    codexHome: pick(CODEX_HOME_ENV, input.settings.codexHome, input, ".codex")
+  };
 }
-function getClaudeProjectsRoot() {
-  return path$1.join(getClaudeConfigDir(), "projects");
+function agentHomeEnv(homes) {
+  const env = {};
+  if (homes.claudeConfigDir.source !== "default") env[CLAUDE_CONFIG_DIR_ENV] = homes.claudeConfigDir.path;
+  if (homes.codexHome.source !== "default") env[CODEX_HOME_ENV] = homes.codexHome.path;
+  return env;
 }
-function getProjectPath(workingDirectory) {
-  const projectId = path$1.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
-  return path$1.join(getClaudeProjectsRoot(), projectId);
+function claudeProjectDirName(workingDirectory) {
+  return path$1.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+}
+function claudeConversationPath(configDir, workingDirectory, claudeSessionId) {
+  return path$1.join(configDir, "projects", claudeProjectDirName(workingDirectory), `${claudeSessionId}.jsonl`);
+}
+function agentHomeCandidates(kind, input, homes = resolveAgentHomes(input)) {
+  const envName = kind === "claude" ? CLAUDE_CONFIG_DIR_ENV : CODEX_HOME_ENV;
+  const resolved = kind === "claude" ? homes.claudeConfigDir : homes.codexHome;
+  const raw = [
+    resolved.path,
+    nonEmpty(kind === "claude" ? input.settings.claudeConfigDir : input.settings.codexHome),
+    nonEmpty(input.loginShellEnv?.[envName]),
+    nonEmpty(input.daemonEnv[envName]),
+    path$1.join(input.homeDir, kind === "claude" ? ".claude" : ".codex")
+  ];
+  const out = [];
+  for (const value of raw) {
+    if (!value) continue;
+    const expanded = expandHomePath(value, input.homeDir);
+    if (!out.includes(expanded)) out.push(expanded);
+  }
+  return out;
+}
+function findClaudeConversation(claudeSessionId, workingDirectory, candidates, fileSize) {
+  let best = null;
+  let bestSize = -1;
+  for (let i = 0; i < candidates.length; i++) {
+    const file = claudeConversationPath(candidates[i], workingDirectory, claudeSessionId);
+    const size = fileSize(file);
+    if (size === null || size <= bestSize) continue;
+    best = { home: candidates[i], file, resolved: i === 0 };
+    bestSize = size;
+  }
+  return best;
+}
+function codexRolloutFileMatches(fileName, threadId) {
+  return fileName.startsWith("rollout-") && fileName.endsWith(`-${threadId}.jsonl`);
+}
+function findCodexThread(threadId, candidates, listDir) {
+  const digits = /^\d+$/;
+  for (let i = 0; i < candidates.length; i++) {
+    const sessions = path$1.join(candidates[i], "sessions");
+    for (const year of listDir(sessions).filter((name) => digits.test(name)).sort().reverse()) {
+      for (const month of listDir(path$1.join(sessions, year)).filter((name) => digits.test(name)).sort().reverse()) {
+        for (const day of listDir(path$1.join(sessions, year, month)).filter((name) => digits.test(name)).sort().reverse()) {
+          const dayDir = path$1.join(sessions, year, month, day);
+          const hit = listDir(dayDir).find((name) => codexRolloutFileMatches(name, threadId));
+          if (hit) return { home: candidates[i], file: path$1.join(dayDir, hit), resolved: i === 0 };
+        }
+      }
+    }
+  }
+  return null;
+}
+function describeAgentHome(choice) {
+  const source = {
+    settings: "settings.json",
+    "login-shell": "login shell",
+    "daemon-env": "daemon environment",
+    default: "default"
+  };
+  return `${choice.path} (${source[choice.source]})`;
 }
 
+const LOGIN_SHELL_ENV_MARKER = "__VH_ENV__";
+const LOGIN_SHELL_PROBE_TIMEOUT_MS = 3e3;
+function loginShellProbeScript(names) {
+  const pairs = names.map((name) => `${name} "$${name}"`).join(" ");
+  return `printf '${LOGIN_SHELL_ENV_MARKER}%s=%s\\n' ${pairs}`;
+}
+function parseLoginShellEnv(output, names) {
+  const wanted = new Set(names);
+  const env = {};
+  for (const rawLine of output.split(/\r?\n/)) {
+    const at = rawLine.indexOf(LOGIN_SHELL_ENV_MARKER);
+    if (at < 0) continue;
+    const line = rawLine.slice(at + LOGIN_SHELL_ENV_MARKER.length);
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const name = line.slice(0, eq);
+    if (!wanted.has(name)) continue;
+    const value = line.slice(eq + 1).trim();
+    env[name] = value ? value : void 0;
+  }
+  return env;
+}
+function probeLoginShellEnv(names, options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") return Promise.resolve(null);
+  const shell = (options.shell ?? process.env.SHELL ?? "").trim() || "/bin/sh";
+  const timeoutMs = options.timeoutMs ?? LOGIN_SHELL_PROBE_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let stdout = "";
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    let child;
+    try {
+      child = node_child_process.spawn(shell, ["-l", "-i", "-c", loginShellProbeScript(names)], {
+        stdio: ["ignore", "pipe", "ignore"],
+        env: options.env ?? process.env,
+        windowsHide: true
+      });
+    } catch {
+      resolve(null);
+      return;
+    }
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      finish(null);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.on("error", () => finish(null));
+    child.on("close", () => {
+      finish(stdout.includes(LOGIN_SHELL_ENV_MARKER) ? parseLoginShellEnv(stdout, names) : null);
+    });
+  });
+}
+
+const AGENT_HOME_CACHE_MS = 6e4;
+const AGENT_HOME_FAILURE_CACHE_MS = 5 * 6e4;
+let cache = null;
+let inFlight = null;
+let originalDaemonEnv = null;
+function snapshotDaemonEnv() {
+  if (!originalDaemonEnv) {
+    originalDaemonEnv = {};
+    for (const name of AGENT_HOME_ENV_NAMES) originalDaemonEnv[name] = process.env[name];
+  }
+  return originalDaemonEnv;
+}
+async function load(now) {
+  const settings = await persistence.readSettings();
+  const loginShellEnv = await probeLoginShellEnv(AGENT_HOME_ENV_NAMES);
+  const input = {
+    settings: { claudeConfigDir: settings.claudeConfigDir, codexHome: settings.codexHome },
+    daemonEnv: snapshotDaemonEnv(),
+    loginShellEnv,
+    homeDir: os$1.homedir()
+  };
+  const homes = resolveAgentHomes(input);
+  return {
+    input,
+    homes,
+    expiresAt: now + (loginShellEnv ? AGENT_HOME_CACHE_MS : AGENT_HOME_FAILURE_CACHE_MS)
+  };
+}
+async function refreshAgentHomes(now = Date.now()) {
+  if (cache && cache.expiresAt > now) return cache.homes;
+  if (!inFlight) {
+    inFlight = load(now).finally(() => {
+      inFlight = null;
+    });
+  }
+  let entry;
+  try {
+    entry = await inFlight;
+  } catch (error) {
+    persistence.logger.debug("[AGENT HOME] resolve failed, falling back", error);
+    if (cache) return cache.homes;
+    const input = { settings: {}, daemonEnv: snapshotDaemonEnv(), loginShellEnv: null, homeDir: os$1.homedir() };
+    return resolveAgentHomes(input);
+  }
+  const previous = cache?.homes;
+  cache = entry;
+  applyAgentHomesToProcessEnv(entry.homes);
+  if (!previous || previous.claudeConfigDir.path !== entry.homes.claudeConfigDir.path || previous.codexHome.path !== entry.homes.codexHome.path) {
+    persistence.logger.debug(`[AGENT HOME] Claude config dir: ${describeAgentHome(entry.homes.claudeConfigDir)}; Codex home: ${describeAgentHome(entry.homes.codexHome)}`);
+  }
+  return entry.homes;
+}
+function currentAgentHomes() {
+  return cache?.homes ?? null;
+}
+function resetAgentHomesCache() {
+  cache = null;
+  inFlight = null;
+  originalDaemonEnv = null;
+}
+function applyAgentHomesToProcessEnv(homes) {
+  const overlay = agentHomeEnv(homes);
+  for (const name of 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 = cache;
+  if (!entry) {
+    const input = { settings: {}, daemonEnv: process.env, loginShellEnv: null, homeDir: os$1.homedir() };
+    return findClaudeConversation(claudeSessionId, workingDirectory, agentHomeCandidates("claude", input), fileSizeSafe);
+  }
+  return findClaudeConversation(claudeSessionId, workingDirectory, agentHomeCandidates("claude", entry.input, entry.homes), fileSizeSafe);
+}
+function locateCodexThread(codexThreadId) {
+  const entry = cache;
+  const input = entry?.input ?? { settings: {}, daemonEnv: process.env, loginShellEnv: null, homeDir: os$1.homedir() };
+  return findCodexThread(codexThreadId, 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[CLAUDE_CONFIG_DIR_ENV] = hit.home;
+      persistence.logger.debug(`[AGENT HOME] Claude conversation ${input.claudeSessionId} found under ${hit.home}; overriding ${CLAUDE_CONFIG_DIR_ENV} for this spawn`);
+    }
+  }
+  if (input.codexThreadId) {
+    const hit = locateCodexThread(input.codexThreadId);
+    if (hit && !hit.resolved) {
+      env[CODEX_HOME_ENV] = hit.home;
+      persistence.logger.debug(`[AGENT HOME] Codex thread ${input.codexThreadId} found under ${hit.home}; overriding ${CODEX_HOME_ENV} for this spawn`);
+    }
+  }
+  return env;
+}
+
+var index = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  AGENT_HOME_CACHE_MS: AGENT_HOME_CACHE_MS,
+  AGENT_HOME_ENV_NAMES: AGENT_HOME_ENV_NAMES,
+  AGENT_HOME_FAILURE_CACHE_MS: AGENT_HOME_FAILURE_CACHE_MS,
+  CLAUDE_CONFIG_DIR_ENV: CLAUDE_CONFIG_DIR_ENV,
+  CODEX_HOME_ENV: CODEX_HOME_ENV,
+  agentHomeCandidates: agentHomeCandidates,
+  agentHomeEnv: agentHomeEnv,
+  agentHomeSpawnEnv: agentHomeSpawnEnv,
+  claudeConversationPath: claudeConversationPath,
+  claudeProjectDirName: claudeProjectDirName,
+  codexRolloutFileMatches: codexRolloutFileMatches,
+  currentAgentHomes: currentAgentHomes,
+  describeAgentHome: describeAgentHome,
+  expandHomePath: expandHomePath,
+  findClaudeConversation: findClaudeConversation,
+  findCodexThread: findCodexThread,
+  locateClaudeConversation: locateClaudeConversation,
+  locateCodexThread: locateCodexThread,
+  probeLoginShellEnv: probeLoginShellEnv,
+  refreshAgentHomes: refreshAgentHomes,
+  resetAgentHomesCache: resetAgentHomesCache,
+  resolveAgentHomes: resolveAgentHomes
+});
+
 var xtermHeadless = {};
 
 var hasRequiredXtermHeadless;
@@ -11342,7 +11640,8 @@ class WebTerminalManager {
           return false;
         }
       },
-      conversationExists: (cwd, claudeSessionId) => node_fs.existsSync(path$1.join(getProjectPath(cwd), `${claudeSessionId}.jsonl`)),
+      // B-478: every Claude config dir the user might have pointed a shell at.
+      conversationExists: (cwd, claudeSessionId) => locateClaudeConversation(cwd, claudeSessionId) !== null,
       // B-273: only consulted for records that were attach terminals.
       // Unbounded: the panel's 50-row cap must not hide a restore target.
       userSessions: record.attachTmux ? this.listUserTmuxSessions(Infinity) : [],
@@ -12692,6 +12991,17 @@ function detectResumeSupport(happyHomeDir = persistence.configuration.happyHomeD
   };
 }
 
+function getClaudeConfigDir() {
+  return process.env.CLAUDE_CONFIG_DIR || path$1.join(os$1.homedir(), ".claude");
+}
+function getClaudeProjectsRoot() {
+  return path$1.join(getClaudeConfigDir(), "projects");
+}
+function getProjectPath(workingDirectory) {
+  const projectId = path$1.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+  return path$1.join(getClaudeProjectsRoot(), projectId);
+}
+
 const TITLE_PROMPT_PREFIX = "Summarize the SPECIFIC topic/request of this message into a 3-6 word title";
 const BOARD_ANALYZER_PROMPT_PREFIX = "You are a status analyzer for a task board of coding-agent sessions.";
 const VERY_HAPPY_ONE_SHOT_PROMPT_PREFIXES = [
@@ -17001,6 +17311,7 @@ const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
   }).passthrough()
 ]);
 
+exports.AGENT_HOME_ENV_NAMES = AGENT_HOME_ENV_NAMES;
 exports.AGENT_VERSION_SOURCES = AGENT_VERSION_SOURCES;
 exports.ApiClient = ApiClient;
 exports.ApiSessionClient = ApiSessionClient;
@@ -17018,6 +17329,7 @@ exports.RawJSONLinesSchema = RawJSONLinesSchema;
 exports.STREAM_DELTA_MAX_CHARS = STREAM_DELTA_MAX_CHARS;
 exports.TITLE_PROMPT_PREFIX = TITLE_PROMPT_PREFIX;
 exports.TurnActivityTracker = TurnActivityTracker;
+exports.agentHomeSpawnEnv = agentHomeSpawnEnv;
 exports.api = api;
 exports.checkIfDaemonRunningAndCleanupStaleState = checkIfDaemonRunningAndCleanupStaleState;
 exports.cleanupDaemonState = cleanupDaemonState;
@@ -17031,13 +17343,16 @@ exports.decideBackfill = decideBackfill;
 exports.decideMirrorBinding = decideMirrorBinding;
 exports.delay = delay;
 exports.deriveLocalCliUpdateSummary = deriveLocalCliUpdateSummary;
+exports.describeAgentHome = describeAgentHome;
 exports.detectCLIAvailability = detectCLIAvailability;
 exports.detectResumeSupport = detectResumeSupport;
 exports.errorLogMetadata = errorLogMetadata;
+exports.expandHomePath = expandHomePath;
 exports.extractCompleteLines = extractCompleteLines;
 exports.fetchCliUpdateState = fetchCliUpdateState;
 exports.getLocalHappyAgentCredentialPath = getLocalHappyAgentCredentialPath;
 exports.getProjectPath = getProjectPath;
+exports.index = index;
 exports.initializeSandbox = initializeSandbox;
 exports.isClaudeSessionId = isClaudeSessionId;
 exports.isDaemonRunningCurrentlyInstalledHappyVersion = isDaemonRunningCurrentlyInstalledHappyVersion;
@@ -17045,6 +17360,7 @@ exports.isValidSessionId = isValidSessionId;
 exports.isValidTerminalId = isValidTerminalId;
 exports.listDaemonSessions = listDaemonSessions;
 exports.listVhTerminals = listVhTerminals;
+exports.locateClaudeConversation = locateClaudeConversation;
 exports.mirrorLineKey = mirrorLineKey;
 exports.mirrorLocalId = mirrorLocalId;
 exports.notifyDaemonClaudeAuthFailed = notifyDaemonClaudeAuthFailed;
@@ -17052,10 +17368,13 @@ exports.notifyDaemonSessionEvent = notifyDaemonSessionEvent;
 exports.notifyDaemonSessionStarted = notifyDaemonSessionStarted;
 exports.parseExactVersion = parseExactVersion;
 exports.parseTerminalHookPayload = parseTerminalHookPayload;
+exports.probeLoginShellEnv = probeLoginShellEnv;
 exports.pushClipboardViaDaemon = pushClipboardViaDaemon;
 exports.pushFilePreviewViaDaemon = pushFilePreviewViaDaemon;
 exports.readLocalHappyAgentCredentials = readLocalHappyAgentCredentials;
 exports.readVhTerminal = readVhTerminal;
+exports.refreshAgentHomes = refreshAgentHomes;
+exports.resolveAgentHomes = resolveAgentHomes;
 exports.resolveCliUpdateCheckInterval = resolveCliUpdateCheckInterval;
 exports.scrubTmuxClientEnv = scrubTmuxClientEnv;
 exports.sendToVhTerminal = sendToVhTerminal;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "very-happy-cli",
-  "version": "0.2.143",
+  "version": "0.2.144",
   "description": "Remote multi-agent workspace CLI with deep Claude integration, native terminal streaming, and self-hosting.",
   "author": "Kirill Dubovitskiy",
   "contributors": [
@@ -117,12 +117,12 @@
     "zod": "^4.0.0"
   },
   "optionalDependencies": {
-    "very-happy-tools-arm64-darwin": "0.2.143",
-    "very-happy-tools-x64-darwin": "0.2.143",
-    "very-happy-tools-arm64-linux": "0.2.143",
-    "very-happy-tools-x64-linux": "0.2.143",
-    "very-happy-tools-arm64-win32": "0.2.143",
-    "very-happy-tools-x64-win32": "0.2.143"
+    "very-happy-tools-arm64-darwin": "0.2.144",
+    "very-happy-tools-x64-darwin": "0.2.144",
+    "very-happy-tools-arm64-linux": "0.2.144",
+    "very-happy-tools-x64-linux": "0.2.144",
+    "very-happy-tools-arm64-win32": "0.2.144",
+    "very-happy-tools-x64-win32": "0.2.144"
   },
   "devDependencies": {
     "@slopus/happy-wire": "workspace:*",