very-happy-cli 0.2.158 → 0.2.160

package/dist/logger-CS0mw3fa.cjs

@@ -0,0 +1,275 @@
+'use strict';
+
+var chalk = require('chalk');
+var node_util = require('node:util');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+var node_fs = require('node:fs');
+var path = require('node:path');
+
+function sensitiveKey(key) {
+  const normalized = key.toLowerCase().replace(/[_\-\s]/g, "");
+  return /(token|secret|password|authorization|cookie|credential|apikey|privatekey|encryptionkey|accesskey|claimsecret)/.test(normalized);
+}
+function redactLogString(value) {
+  return value.replace(/(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[REDACTED]").replace(/([?&](?:token|secret|password|api[_-]?key)=)[^&#\s]+/gi, "$1[REDACTED]").replace(/((?:token|secret|password|api[_-]?key)\s*[=:]\s*)[^\s,;]+/gi, "$1[REDACTED]");
+}
+function redactLogValue(value, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+  if (typeof value === "string") return redactLogString(value);
+  if (value === null || typeof value !== "object") return value;
+  if (depth >= 6) return "[TRUNCATED]";
+  if (seen.has(value)) return "[CIRCULAR]";
+  seen.add(value);
+  if (value instanceof Error) {
+    const error = value;
+    return {
+      name: error.name,
+      message: redactLogString(error.message),
+      ...typeof error.code === "string" || typeof error.code === "number" ? { code: error.code } : {},
+      ...typeof (error.status ?? error.response?.status) === "number" ? { status: error.status ?? error.response?.status } : {}
+    };
+  }
+  if (Array.isArray(value)) return value.map((item) => redactLogValue(item, depth + 1, seen));
+  const result = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (sensitiveKey(key)) {
+      result[key] = "[REDACTED]";
+    } else if (key === "environmentVariables" && child && typeof child === "object") {
+      result[key] = { names: Object.keys(child).sort() };
+    } else {
+      result[key] = redactLogValue(child, depth + 1, seen);
+    }
+  }
+  return result;
+}
+
+function createTimestampForFilename(date = /* @__PURE__ */ new Date()) {
+  return date.toLocaleString("sv-SE", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).replace(/[: ]/g, "-").replace(/,/g, "") + "-pid-" + process.pid;
+}
+function createTimestampForLogEntry(date = /* @__PURE__ */ new Date()) {
+  return date.toLocaleTimeString("en-US", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    fractionalSecondDigits: 3
+  });
+}
+function getSessionLogPath() {
+  const timestamp = createTimestampForFilename();
+  const filename = configuration.configuration.isDaemonProcess ? `${timestamp}-daemon.log` : `${timestamp}.log`;
+  return path.join(configuration.configuration.logsDir, filename);
+}
+function safeRemoteLogUrl(raw) {
+  if (!raw) return void 0;
+  try {
+    const url = new URL(raw);
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) return void 0;
+    if (url.username || url.password || url.search || url.hash || url.pathname !== "/" && url.pathname !== "") return void 0;
+    return url.origin;
+  } catch {
+    return void 0;
+  }
+}
+class Logger {
+  constructor(logFilePath = getSessionLogPath()) {
+    this.logFilePath = logFilePath;
+    const remoteUrl = safeRemoteLogUrl(process.env.HAPPY_SERVER_URL);
+    const remoteToken = process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING_TOKEN;
+    if (process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING && remoteUrl && remoteToken && Buffer.byteLength(remoteToken) >= 32) {
+      this.dangerouslyUnencryptedServerLoggingUrl = remoteUrl;
+      this.dangerouslyUnencryptedServerLoggingToken = remoteToken;
+      console.log(chalk.yellow("[REMOTE LOGGING] Sending logs to server for AI debugging"));
+    }
+  }
+  dangerouslyUnencryptedServerLoggingUrl;
+  dangerouslyUnencryptedServerLoggingToken;
+  // Use local timezone for simplicity of locating the logs,
+  // in practice you will not need absolute timestamps
+  localTimezoneTimestamp() {
+    return createTimestampForLogEntry();
+  }
+  debug(message, ...args) {
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, ...args);
+  }
+  debugLargeJson(message, object, maxStringLength = 100, maxArrayLength = 10) {
+    if (!process.env.DEBUG) {
+      this.debug(`In production, skipping message inspection`);
+      return;
+    }
+    const truncateStrings = (obj) => {
+      if (typeof obj === "string") {
+        return obj.length > maxStringLength ? obj.substring(0, maxStringLength) + "... [truncated for logs]" : obj;
+      }
+      if (Array.isArray(obj)) {
+        const truncatedArray = obj.map((item) => truncateStrings(item)).slice(0, maxArrayLength);
+        if (obj.length > maxArrayLength) {
+          truncatedArray.push(`... [truncated array for logs up to ${maxArrayLength} items]`);
+        }
+        return truncatedArray;
+      }
+      if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+          if (key === "usage") {
+            continue;
+          }
+          result[key] = truncateStrings(value);
+        }
+        return result;
+      }
+      return obj;
+    };
+    const truncatedObject = truncateStrings(redactLogValue(object));
+    const json = JSON.stringify(truncatedObject, null, 2);
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, redactLogString(message), "\n", json);
+  }
+  info(message, ...args) {
+    this.logToConsole("info", "", message, ...args);
+    this.debug(message, args);
+  }
+  infoDeveloper(message, ...args) {
+    this.debug(message, ...args);
+    if (process.env.DEBUG) {
+      this.logToConsole("info", "[DEV]", message, ...args);
+    }
+  }
+  warn(message, ...args) {
+    this.logToConsole("warn", "", message, ...args);
+    this.debug(`[WARN] ${message}`, ...args);
+  }
+  getLogPath() {
+    return this.logFilePath;
+  }
+  logToConsole(level, prefix, message, ...args) {
+    message = redactLogString(message);
+    args = args.map((arg) => redactLogValue(arg));
+    switch (level) {
+      case "debug": {
+        console.log(chalk.gray(prefix), message, ...args);
+        break;
+      }
+      case "error": {
+        console.error(chalk.red(prefix), message, ...args);
+        break;
+      }
+      case "info": {
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
+      case "warn": {
+        console.log(chalk.yellow(prefix), message, ...args);
+        break;
+      }
+      default: {
+        this.debug("Unknown log level:", level);
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
+    }
+  }
+  async sendToRemoteServer(level, message, ...args) {
+    if (!this.dangerouslyUnencryptedServerLoggingUrl) return;
+    try {
+      await fetch(this.dangerouslyUnencryptedServerLoggingUrl + "/logs-combined-from-cli-and-mobile-for-simple-ai-debugging", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.dangerouslyUnencryptedServerLoggingToken}`
+        },
+        body: JSON.stringify({
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          level,
+          message: `${redactLogString(message)} ${args.map((raw) => {
+            const safe = redactLogValue(raw);
+            return typeof safe === "object" ? JSON.stringify(safe, null, 2) : String(safe);
+          }).join(" ")}`,
+          source: "cli",
+          platform: process.platform
+        })
+      });
+    } catch (error) {
+    }
+  }
+  logToFile(prefix, message, ...args) {
+    const safeMessage = redactLogString(message);
+    const safeArgs = args.map((arg) => redactLogValue(arg));
+    const logLine = `${prefix} ${safeMessage} ${safeArgs.map(
+      (arg) => typeof arg === "string" ? arg : node_util.inspect(arg, { depth: 5, breakLength: 120 })
+    ).join(" ")}
+`;
+    if (this.dangerouslyUnencryptedServerLoggingUrl) {
+      let level = "info";
+      if (prefix.includes(this.localTimezoneTimestamp())) {
+        level = "debug";
+      }
+      this.sendToRemoteServer(level, safeMessage, ...safeArgs).catch(() => {
+      });
+    }
+    try {
+      configuration.appendPrivateFileSync(this.logFilePath, logLine);
+    } catch (appendError) {
+      if (process.env.DEBUG) {
+        console.error("[DEV MODE ONLY THROWING] Failed to append to log file:", appendError);
+        throw appendError;
+      }
+    }
+  }
+}
+let logger = new Logger();
+async function listDaemonLogFiles(limit = 50) {
+  try {
+    const logsDir = configuration.configuration.logsDir;
+    if (!node_fs.existsSync(logsDir)) {
+      return [];
+    }
+    const logs = node_fs.readdirSync(logsDir).filter((file) => file.endsWith("-daemon.log")).map((file) => {
+      const fullPath = path.join(logsDir, file);
+      const stats = node_fs.statSync(fullPath);
+      return { file, path: fullPath, modified: stats.mtime };
+    }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    try {
+      const { readDaemonState } = await Promise.resolve().then(function () { return require('./persistence-yKTH3-5X.cjs'); });
+      const state = await readDaemonState();
+      if (!state) {
+        return logs;
+      }
+      if (state.daemonLogPath && node_fs.existsSync(state.daemonLogPath)) {
+        const stats = node_fs.statSync(state.daemonLogPath);
+        const persisted = {
+          file: path.basename(state.daemonLogPath),
+          path: state.daemonLogPath,
+          modified: stats.mtime
+        };
+        const idx = logs.findIndex((l) => l.path === persisted.path);
+        if (idx >= 0) {
+          const [found] = logs.splice(idx, 1);
+          logs.unshift(found);
+        } else {
+          logs.unshift(persisted);
+        }
+      }
+    } catch {
+    }
+    return logs.slice(0, Math.max(0, limit));
+  } catch {
+    return [];
+  }
+}
+async function getLatestDaemonLog() {
+  const [latest] = await listDaemonLogFiles(1);
+  return latest || null;
+}
+
+exports.getLatestDaemonLog = getLatestDaemonLog;
+exports.logger = logger;
+exports.redactLogValue = redactLogValue;

package/dist/loginShellEnv-BkuYtExZ.cjs

@@ -0,0 +1,182 @@
+'use strict';
+
+var path = require('node:path');
+var node_child_process = require('node:child_process');
+
+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.join(homeDir, trimmed.slice(2));
+  return path.isAbsolute(trimmed) ? trimmed : path.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.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 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 claudeProjectDirName(workingDirectory) {
+  return path.resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+}
+function claudeConversationPath(configDir, workingDirectory, claudeSessionId) {
+  return path.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.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.join(candidates[i], "sessions");
+    for (const year of listDir(sessions).filter((name) => digits.test(name)).sort().reverse()) {
+      for (const month of listDir(path.join(sessions, year)).filter((name) => digits.test(name)).sort().reverse()) {
+        for (const day of listDir(path.join(sessions, year, month)).filter((name) => digits.test(name)).sort().reverse()) {
+          const dayDir = path.join(sessions, year, month, day);
+          const hit = listDir(dayDir).find((name) => codexRolloutFileMatches(name, threadId));
+          if (hit) return { home: candidates[i], file: path.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);
+    });
+  });
+}
+
+exports.AGENT_HOME_ENV_NAMES = AGENT_HOME_ENV_NAMES;
+exports.CLAUDE_CONFIG_DIR_ENV = CLAUDE_CONFIG_DIR_ENV;
+exports.CODEX_HOME_ENV = CODEX_HOME_ENV;
+exports.agentHomeCandidates = agentHomeCandidates;
+exports.agentHomeEnv = agentHomeEnv;
+exports.claudeConversationPath = claudeConversationPath;
+exports.claudeProjectDirName = claudeProjectDirName;
+exports.codexRolloutFileMatches = codexRolloutFileMatches;
+exports.describeAgentHome = describeAgentHome;
+exports.expandHomePath = expandHomePath;
+exports.findClaudeConversation = findClaudeConversation;
+exports.findCodexThread = findCodexThread;
+exports.probeLoginShellEnv = probeLoginShellEnv;
+exports.resolveAgentHomes = resolveAgentHomes;

package/dist/loginShellEnv-Dw8M7tkI.mjs

@@ -0,0 +1,167 @@
+import { join, resolve, isAbsolute } from 'node:path';
+import { spawn } from 'node:child_process';
+
+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 join(homeDir, trimmed.slice(2));
+  return isAbsolute(trimmed) ? trimmed : 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: 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 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 claudeProjectDirName(workingDirectory) {
+  return resolve(workingDirectory).replace(/[^a-zA-Z0-9-]/g, "-");
+}
+function claudeConversationPath(configDir, workingDirectory, claudeSessionId) {
+  return 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]),
+    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 = join(candidates[i], "sessions");
+    for (const year of listDir(sessions).filter((name) => digits.test(name)).sort().reverse()) {
+      for (const month of listDir(join(sessions, year)).filter((name) => digits.test(name)).sort().reverse()) {
+        for (const day of listDir(join(sessions, year, month)).filter((name) => digits.test(name)).sort().reverse()) {
+          const dayDir = join(sessions, year, month, day);
+          const hit = listDir(dayDir).find((name) => codexRolloutFileMatches(name, threadId));
+          if (hit) return { home: candidates[i], file: 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 = 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);
+    });
+  });
+}
+
+export { AGENT_HOME_ENV_NAMES as A, CLAUDE_CONFIG_DIR_ENV as C, CODEX_HOME_ENV as a, agentHomeCandidates as b, findCodexThread as c, describeAgentHome as d, expandHomePath as e, findClaudeConversation as f, agentHomeEnv as g, claudeConversationPath as h, claudeProjectDirName as i, codexRolloutFileMatches as j, probeLoginShellEnv as p, resolveAgentHomes as r };

package/dist/machineMetadata-DyDbODYd.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var os = require('node:os');
+var _package = require('./package-BwMrPwqH.cjs');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var detectCLI = require('./detectCLI-DR9ZaN6B.cjs');
+var localHappyAgentAuth = require('./localHappyAgentAuth-D6rFhaoc.cjs');
+
+function buildInitialMachineMetadata(cliAvailability) {
+  const hostSuffix = process.env.HAPPY_VARIANT === "dev" ? "-dev" : "";
+  return {
+    teamsVersion: 1,
+    teamLaunchVersion: 1,
+    host: os.hostname() + hostSuffix,
+    platform: os.platform(),
+    happyCliVersion: _package.packageJson.version,
+    homeDir: os.homedir(),
+    happyHomeDir: configuration.configuration.happyHomeDir,
+    happyLibDir: projectPath.projectPath(),
+    cliAvailability,
+    resumeSupport: { ...localHappyAgentAuth.detectResumeSupport(), rpcAvailable: true }
+  };
+}
+let memo = null;
+function compute() {
+  if (!memo) {
+    const cliAvailability = detectCLI.detectCLIAvailability();
+    memo = { metadata: buildInitialMachineMetadata(cliAvailability), cliAvailability };
+  }
+  return memo;
+}
+function getInitialMachineMetadata() {
+  return compute().metadata;
+}
+function getStartupCliAvailability() {
+  return compute().cliAvailability;
+}
+
+exports.getInitialMachineMetadata = getInitialMachineMetadata;
+exports.getStartupCliAvailability = getStartupCliAvailability;