very-happy-cli 0.2.158 → 0.2.160

package/dist/index-DDeHXrIX.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+var _package = require('./package-BwMrPwqH.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-Dc-mNSLb.cjs'); });
+    process.exit(await selfCheckMain({ verbose: isSelfCheckRequest(args) }));
+  }
+  const { main } = await Promise.resolve().then(function () { return require('./main-BkxJP6JQ.cjs'); });
+  await main();
+}
+void run(process.argv.slice(2));
+
+exports.isStandaloneVersionRequest = isStandaloneVersionRequest;
+exports.pruneStaleCompileCaches = pruneStaleCompileCaches;

package/dist/index-DKLU_fD0.mjs

@@ -0,0 +1,158 @@
+import { statSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { readSettings } from './persistence-HGW_ZVs9.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-RfeNjFmd.mjs';
+import 'node:path';
+import './package-BhaKlnxz.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-ZChGsuB7.mjs → index-DMZqWwsP.mjs}

@@ -1,56 +1,86 @@
-import { D as DefaultTransport, A as AcpBackend } from './AcpBackend-vDVLHuYJ.mjs';
-export { a as DEFAULT_IDLE_TIMEOUT_MS, b as DEFAULT_TOOL_CALL_TIMEOUT_MS, e as extractErrorDetail, f as formatDuration, c as formatDurationMinutes, h as handleAgentMessageChunk, d as handleAgentThoughtChunk, g as handleLegacyMessageChunk, i as handlePlanUpdate, j as handleThinkingUpdate, k as handleToolCall, l as handleToolCallUpdate, p as parseArgsFromContent } from './AcpBackend-vDVLHuYJ.mjs';
-import { r as readSettings, v as notifyDaemonSessionStarted, w as encodeBase64, l as logger, x as BUILTIN_TODO_DISCOVERY, c as configuration, y as reportSessionEditToDaemon } from './limits-D2uN090G.mjs';
-import { A as AcpSessionManager } from './AcpSessionManager-CmRjfhn3.mjs';
-import { h as initialMachineMetadata, j as createSessionMetadata, k as setupOfflineReconnection, l as StreamRelay, M as MessageQueue2, m as hashObject, n as startHappyServer, o as registerAgentAttachmentDownloads, u as TitleGenerator, v as registerKillSessionHandler, C as CLAUDE_ATTACHMENT_KINDS, w as stageClaudeAttachments, x as appendStagedAttachmentsToPrompt, B as BasePermissionHandler, E as EditReportThrottle, y as extractAcpEditPaths, z as writeSessionModeFile, F as normalizeAcpPermissionMode, H as removeSessionModeFile } from './index-CVCt3kSt.mjs';
-import { p as preparePiTeamsRuntime } from './piRuntime-bkw2NAZU.mjs';
+import { D as DefaultTransport, A as AcpBackend } from './AcpBackend-mzv8Dhba.mjs';
+export { a as DEFAULT_IDLE_TIMEOUT_MS, b as DEFAULT_TOOL_CALL_TIMEOUT_MS, e as extractErrorDetail, f as formatDuration, c as formatDurationMinutes, h as handleAgentMessageChunk, d as handleAgentThoughtChunk, g as handleLegacyMessageChunk, i as handlePlanUpdate, j as handleThinkingUpdate, k as handleToolCall, l as handleToolCallUpdate, p as parseArgsFromContent } from './AcpBackend-mzv8Dhba.mjs';
+import { l as logger } from './logger-6HYUEXNk.mjs';
+import { A as AcpSessionManager } from './AcpSessionManager-CoMWFVw3.mjs';
+import { l as BUILTIN_TODO_DISCOVERY, P as PROMPT_QUEUE_CAPABILITY } from './index-qdS1friN.mjs';
+import { r as registerAgentAttachmentDownloads } from './agentAttachments-M_B5qEF2.mjs';
+import { c as configuration } from './configuration-RfeNjFmd.mjs';
+import { C as CLAUDE_ATTACHMENT_KINDS, a as stageClaudeAttachments, b as appendStagedAttachmentsToPrompt } from './attachmentContent-_kxRznNf.mjs';
+import { p as preparePiTeamsRuntime } from './piRuntime-CSGkwCKQ.mjs';
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
-import { h as connectionState, A as ApiClient } from './types-DIBF4U0Y.mjs';
-import { p as projectPath } from './terminalTitleSuggest-DKgX3osW.mjs';
+import { c as connectionState, A as ApiClient } from './api-CLMUr-SX.mjs';
+import { M as MessageQueue2, r as registerKillSessionHandler } from './registerKillSessionHandler-GYvHdipX.mjs';
+import { h as hashObject, s as startHappyServer } from './deterministicJson-CzkFJWw1.mjs';
+import { readSettings } from './persistence-HGW_ZVs9.mjs';
+import { g as getInitialMachineMetadata } from './machineMetadata-oOzBfDfs.mjs';
+import { c as createSessionMetadata } from './createSessionMetadata-CVVkGjxV.mjs';
+import { s as setupOfflineReconnection } from './setupOfflineReconnection-DpvWTt69.mjs';
+import { n as notifyDaemonSessionStarted, g as reportSessionEditToDaemon } from './controlClient-BGbDcgWS.mjs';
+import { e as encodeBase64 } from './authRelay-DSAvg1uv.mjs';
+import { S as StreamRelay } from './streamRelay-FPVbHpbM.mjs';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { B as BasePermissionHandler } from './BasePermissionHandler-m3WVholL.mjs';
+import { T as TitleGenerator } from './titleGenerator-CQ8CoGhg.mjs';
+import { w as writeSessionModeFile, n as normalizeAcpPermissionMode, r as removeSessionModeFile } from './sessionModeFile-DMl3dw3r.mjs';
+import { E as EditReportThrottle, e as extractAcpEditPaths } from './editPaths-BVfS_FFL.mjs';
 import 'node:child_process';
 import '@agentclientprotocol/sdk';
-import 'zod';
-import '@paralleldrive/cuid2';
-import 'node:fs/promises';
-import 'node:fs';
-import 'tweetnacl';
+import './time-D0XyHOid.mjs';
+import './contentLogMetadata-BlWI0egu.mjs';
+import './package-BhaKlnxz.mjs';
 import 'chalk';
 import 'node:util';
+import 'node:fs';
+import '@paralleldrive/cuid2';
+import 'zod';
 import 'node:os';
-import 'cross-spawn';
-import 'node:readline';
-import './agentGuidance-CrR9l62U.mjs';
+import 'node:fs/promises';
+import './attachmentLimits-yba1uHFO.mjs';
+import './resources-BdFBQi8r.mjs';
 import 'axios';
-import 'socket.io-client';
-import 'fs/promises';
-import 'ink';
-import 'react';
-import '@anthropic-ai/claude-agent-sdk';
 import 'node:events';
+import 'socket.io-client';
+import './limits-DIo7rEBR.mjs';
+import './lidState-CeEt442o.mjs';
 import 'os';
 import 'child_process';
-import 'fs';
-import 'path';
-import '@anthropic-ai/sandbox-runtime';
-import 'expo-server-sdk';
+import './registerCommonHandlers-Ccvsz7Ou.mjs';
+import 'util';
+import 'fs/promises';
 import 'crypto';
-import 'ps-list';
-import 'tmp';
-import 'open';
-import 'fastify';
-import 'fastify-type-provider-zod';
-import 'node:module';
+import 'path';
+import 'cross-spawn';
+import './sync-C8gyQFMc.mjs';
+import './backgroundTaskActivity-8PdPxrvy.mjs';
+import 'tweetnacl';
+import './types-CkqAACXx.mjs';
+import './client-CeGKqqcJ.mjs';
+import './context-H0Bcb9S_.mjs';
+import './sessionOps-SuHW8Dfe.mjs';
+import './tools-DkluDcG4.mjs';
+import './tools-BZtHF_qQ.mjs';
+import './client-ClR0K8zX.mjs';
+import './peerTools-BTqw97Gb.mjs';
+import './ids-DU6sLx4C.mjs';
+import './remoteSessionClient-CYnXRynE.mjs';
 import '@modelcontextprotocol/sdk/server/mcp.js';
 import 'node:http';
 import '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import 'http';
-import 'util';
-import 'inquirer';
-import 'node:url';
-import 'node:readline/promises';
-import 'node-pty';
+import './assistantTools-D6tuc6o4.mjs';
+import './terminals-Dlg0x3nY.mjs';
+import './terminalTitleSuggest-CeKsX_V6.mjs';
+import './tmuxSocket-B8Yx20sT.mjs';
+import './bootstrap-hxXPCFMx.mjs';
+import './agentGuidance-CQuNlNx8.mjs';
+import './trimIdent-BAjmv_TG.mjs';
+import './previewPath-CXN4Vag0.mjs';
+import './detectCLI-CSGMlV51.mjs';
+import 'fs';
+import './localHappyAgentAuth-C-HQyiv6.mjs';
 import 'url';
+import 'node:module';
+import './oneShotPrompts-DT4p6RNd.mjs';
 
 function createAcpBackend(options) {
   const backendOptions = {
@@ -596,14 +626,15 @@ async function runAcp(opts) {
   }
   await api.getOrCreateMachine({
     machineId: settings.machineId,
-    metadata: initialMachineMetadata
+    metadata: getInitialMachineMetadata()
   });
   const { state, metadata } = 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
+    sandbox: settings.sandboxConfig,
+    capabilities: [PROMPT_QUEUE_CAPABILITY]
   });
   metadata.attachmentKinds = [];
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
@@ -623,6 +654,7 @@ async function runAcp(opts) {
       if (permissionHandler) {
         permissionHandler.updateSession(newSession);
       }
+      attachPromptQueueDrain(newSession);
     }
   });
   session = initialSession;
@@ -647,6 +679,13 @@ async function runAcp(opts) {
   });
   const sessionManager = new AcpSessionManager(streamingEnabled ? { stream: streamRelay } : {});
   const messageQueue = new MessageQueue2((mode) => hashObject(mode));
+  function attachPromptQueueDrain(client) {
+    const drain = client.attachPromptQueueDrain({
+      isIdle: () => messageQueue.size() === 0 && messageQueue.isWaiting()
+    });
+    messageQueue.setOnWait(() => drain.onIdle());
+  }
+  attachPromptQueueDrain(session);
   let currentPermissionMode;
   let currentModel;
   let modeSelector = null;
@@ -1226,6 +1265,7 @@ ${BUILTIN_TODO_DISCOVERY}`;
       logger.debug(`[${opts.agentName}] Failed to stop Happy MCP server:`, error);
     }
     try {
+      session.closePromptQueueDrain();
       session.updateMetadata((currentMetadata) => ({
         ...currentMetadata,
         lifecycleState: "archived",

package/dist/index-DVkMGPyS.mjs

@@ -0,0 +1,68 @@
+import { p as packageJson } from './package-BhaKlnxz.mjs';
+import module$1 from 'node:module';
+import { existsSync } from 'node:fs';
+import { readdir, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from '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 = homedir()) {
+  return env.HAPPY_HOME_DIR ? env.HAPPY_HOME_DIR.replace(/^~/, home) : join(home, ".happy");
+}
+function compileCacheRoot(happyHomeDir) {
+  return join(happyHomeDir, "cache", "compile");
+}
+function compileCacheDir(happyHomeDir, cliVersion) {
+  return 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 (!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 readdir(root);
+  } catch {
+    return removed;
+  }
+  for (const name of entries) {
+    const dir = join(root, name);
+    if (dir === keep) continue;
+    try {
+      await rm(dir, { recursive: true, force: true });
+      removed.push(name);
+    } catch {
+    }
+  }
+  return removed;
+}
+
+async function run(args) {
+  enableCompileCacheIfPossible(packageJson.version);
+  if (isStandaloneVersionRequest(args) || isSelfCheckRequest(args)) {
+    const { selfCheckMain } = await import('./selfCheck-C9mVrQwf.mjs');
+    process.exit(await selfCheckMain({ verbose: isSelfCheckRequest(args) }));
+  }
+  const { main } = await import('./main-BwNIAI1A.mjs');
+  await main();
+}
+void run(process.argv.slice(2));
+
+export { isStandaloneVersionRequest as i, pruneStaleCompileCaches as p };