very-happy-cli 0.2.159 → 0.2.161

package/dist/index-SPGPenK5.mjs

@@ -0,0 +1,158 @@
+import { statSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { l as logger } from './logger-fXoNzNuB.mjs';
+import { readSettings } from './persistence-oET5n61f.mjs';
+import { d as describeAgentHome, C as CLAUDE_CONFIG_DIR_ENV, a as CODEX_HOME_ENV, f as findClaudeConversation, b as agentHomeCandidates, c as findCodexThread, r as resolveAgentHomes, A as AGENT_HOME_ENV_NAMES, g as agentHomeEnv, p as probeLoginShellEnv } from './loginShellEnv-Dw8M7tkI.mjs';
+export { h as claudeConversationPath, i as claudeProjectDirName, j as codexRolloutFileMatches, e as expandHomePath } from './loginShellEnv-Dw8M7tkI.mjs';
+import 'chalk';
+import 'node:util';
+import './configuration-DoWFJUPm.mjs';
+import 'node:path';
+import './package-uOg9SCKi.mjs';
+import 'node:fs/promises';
+import 'zod';
+import './authRelay-DSAvg1uv.mjs';
+import 'node:crypto';
+import 'tweetnacl';
+import '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 AGENT_HOME_ENV_NAMES) originalDaemonEnv[name] = process.env[name];
+  }
+  return originalDaemonEnv;
+}
+function probeShell(now) {
+  if (!shellProbeInFlight) {
+    const run = probeLoginShellEnv(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.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 = await loginShellEnvFor(now, opts.allowStale === true);
+    const settings = await readSettings();
+    input = {
+      settings: { claudeConfigDir: settings.claudeConfigDir, codexHome: settings.codexHome },
+      daemonEnv: snapshotDaemonEnv(),
+      loginShellEnv,
+      homeDir: homedir()
+    };
+    homes = resolveAgentHomes(input);
+  } catch (error) {
+    logger.debug("[AGENT HOME] resolve failed, falling back", error);
+    if (last) return last.homes;
+    return resolveAgentHomes({ settings: {}, daemonEnv: snapshotDaemonEnv(), loginShellEnv: null, homeDir: 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.debug(`[AGENT HOME] Claude config dir: ${describeAgentHome(homes.claudeConfigDir)}; Codex home: ${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 = 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 readdirSync(path);
+  } catch {
+    return [];
+  }
+}
+function fileSizeSafe(path) {
+  try {
+    const st = 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: 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 = last;
+  const input = entry?.input ?? { settings: {}, daemonEnv: process.env, loginShellEnv: null, homeDir: 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;
+      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;
+      logger.debug(`[AGENT HOME] Codex thread ${input.codexThreadId} found under ${hit.home}; overriding ${CODEX_HOME_ENV} for this spawn`);
+    }
+  }
+  return env;
+}
+
+export { AGENT_HOME_CACHE_MS, AGENT_HOME_ENV_NAMES, AGENT_HOME_FAILURE_CACHE_MS, AGENT_HOME_MAX_STALE_MS, CLAUDE_CONFIG_DIR_ENV, CODEX_HOME_ENV, agentHomeCandidates, agentHomeEnv, agentHomeSpawnEnv, currentAgentHomes, decideShellProbe, describeAgentHome, findClaudeConversation, findCodexThread, locateClaudeConversation, locateCodexThread, probeLoginShellEnv, refreshAgentHomes, resetAgentHomesCache, resolveAgentHomes };

package/dist/index-gNTWtSKN.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+var _package = require('./package-Cl5BEP5x.cjs');
+var module$1 = require('node:module');
+var node_fs = require('node:fs');
+var promises = require('node:fs/promises');
+var os = require('node:os');
+var path = require('node:path');
+
+function isStandaloneVersionRequest(args) {
+  return args.length === 1 && args[0] === "--version";
+}
+const SELF_CHECK_FLAG = "--self-check";
+function isSelfCheckRequest(args) {
+  return args.length === 1 && args[0] === SELF_CHECK_FLAG;
+}
+
+function happyHomeDirFromEnv(env, home = os.homedir()) {
+  return env.HAPPY_HOME_DIR ? env.HAPPY_HOME_DIR.replace(/^~/, home) : path.join(home, ".happy");
+}
+function compileCacheRoot(happyHomeDir) {
+  return path.join(happyHomeDir, "cache", "compile");
+}
+function compileCacheDir(happyHomeDir, cliVersion) {
+  return path.join(compileCacheRoot(happyHomeDir), cliVersion.replace(/[^\w.+-]/g, "_"));
+}
+function enableCompileCacheIfPossible(cliVersion, env = process.env) {
+  try {
+    const enable = module$1.enableCompileCache;
+    if (typeof enable !== "function") return;
+    const happyHome = happyHomeDirFromEnv(env);
+    if (!node_fs.existsSync(happyHome)) return;
+    enable(compileCacheDir(happyHome, cliVersion));
+  } catch {
+  }
+}
+async function pruneStaleCompileCaches(happyHomeDir, cliVersion) {
+  const root = compileCacheRoot(happyHomeDir);
+  const keep = compileCacheDir(happyHomeDir, cliVersion);
+  const removed = [];
+  let entries;
+  try {
+    entries = await promises.readdir(root);
+  } catch {
+    return removed;
+  }
+  for (const name of entries) {
+    const dir = path.join(root, name);
+    if (dir === keep) continue;
+    try {
+      await promises.rm(dir, { recursive: true, force: true });
+      removed.push(name);
+    } catch {
+    }
+  }
+  return removed;
+}
+
+async function run(args) {
+  enableCompileCacheIfPossible(_package.packageJson.version);
+  if (isStandaloneVersionRequest(args) || isSelfCheckRequest(args)) {
+    const { selfCheckMain } = await Promise.resolve().then(function () { return require('./selfCheck-CU8xSDsl.cjs'); });
+    process.exit(await selfCheckMain({ verbose: isSelfCheckRequest(args) }));
+  }
+  const { main } = await Promise.resolve().then(function () { return require('./main-CLaX-t-b.cjs'); });
+  await main();
+}
+void run(process.argv.slice(2));
+
+exports.isStandaloneVersionRequest = isStandaloneVersionRequest;
+exports.pruneStaleCompileCaches = pruneStaleCompileCaches;