very-happy-cli 0.2.158 → 0.2.160

package/dist/controlClient-Bcwv3D21.cjs

@@ -0,0 +1,279 @@
+'use strict';
+
+var logger = require('./logger-CS0mw3fa.cjs');
+var persistence = require('./persistence-yKTH3-5X.cjs');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+
+function daemonControlHeaders(controlToken) {
+  return {
+    "Content-Type": "application/json",
+    ...controlToken ? { Authorization: `Bearer ${controlToken}` } : {}
+  };
+}
+async function daemonPost(path, body) {
+  const state = await persistence.readDaemonState();
+  if (!state?.httpPort) {
+    const errorMessage = "No daemon running, no state file found";
+    logger.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
+  try {
+    process.kill(state.pid, 0);
+  } catch (error) {
+    const errorMessage = "Daemon is not running, file is stale";
+    logger.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
+  try {
+    const timeout = process.env.HAPPY_DAEMON_HTTP_TIMEOUT ? parseInt(process.env.HAPPY_DAEMON_HTTP_TIMEOUT) : 1e4;
+    const response = await fetch(`http://127.0.0.1:${state.httpPort}${path}`, {
+      method: "POST",
+      // A state written by an old daemon has no token and must remain callable;
+      // a new daemon always writes one and rejects requests without it.
+      headers: daemonControlHeaders(state.controlToken),
+      body: JSON.stringify(body || {}),
+      // Mostly increased for stress test
+      signal: AbortSignal.timeout(timeout)
+    });
+    if (!response.ok) {
+      const failure = await response.json().catch(() => null);
+      const reason = typeof failure?.error === "string" && failure.error ? failure.error : `HTTP ${response.status}`;
+      const errorMessage = `Request failed: ${path}, ${reason}`;
+      logger.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+      return {
+        error: errorMessage
+      };
+    }
+    return await response.json();
+  } catch (error) {
+    const errorMessage = `Request failed: ${path}, ${error instanceof Error ? error.message : "Unknown error"}`;
+    logger.logger.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
+}
+const SESSION_STARTED_RETRY_TIMEOUT_MS = 3e3;
+const SESSION_STARTED_RETRY_INTERVAL_MS = 100;
+async function notifyDaemonSessionStarted(sessionId, metadata, encryption) {
+  const payload = { sessionId, metadata, encryption };
+  const deadline = Date.now() + SESSION_STARTED_RETRY_TIMEOUT_MS;
+  let result;
+  while (true) {
+    result = await daemonPost("/session-started", payload);
+    if (!result?.error) {
+      return result;
+    }
+    if (Date.now() >= deadline) {
+      return result;
+    }
+    await new Promise((resolve) => setTimeout(resolve, SESSION_STARTED_RETRY_INTERVAL_MS));
+  }
+}
+async function listDaemonSessions() {
+  const result = await daemonPost("/list");
+  return result.children || [];
+}
+async function stopDaemonSession(sessionId) {
+  const result = await daemonPost("/stop-session", { sessionId });
+  return result.success || false;
+}
+async function spawnDaemonSession(directory, sessionId, opts) {
+  const result = await daemonPost("/spawn-session", {
+    directory,
+    sessionId,
+    spawnedBy: opts?.spawnedBy,
+    permissionMode: opts?.permissionMode,
+    agent: opts?.agent,
+    environmentVariables: opts?.environmentVariables,
+    resumeClaudeSessionId: opts?.resumeClaudeSessionId,
+    resumeCodexThreadId: opts?.resumeCodexThreadId,
+    parentSessionId: opts?.parentSessionId
+  });
+  return result;
+}
+const ROUTE_NOT_FOUND_RE = /, (Not Found|HTTP 404)$/;
+async function resumeDaemonSession(sessionId, opts) {
+  const result = await daemonPost("/resume-session", {
+    sessionId,
+    ...opts?.model !== void 0 ? { model: opts.model } : {},
+    ...opts?.permissionMode !== void 0 ? { permissionMode: opts.permissionMode } : {}
+  });
+  if (result?.error) {
+    const raw = String(result.error);
+    const error = ROUTE_NOT_FOUND_RE.test(raw) ? "daemon too old to resume sessions (no /resume-session route); upgrade very-happy-cli and run `very-happy daemon start`" : raw.replace(/^Request failed: \/resume-session, /, "");
+    return { success: false, error };
+  }
+  if (result?.success === true && typeof result.sessionId === "string") {
+    return { success: true, sessionId: result.sessionId };
+  }
+  return { success: false, error: typeof result?.error === "string" ? result.error : "unexpected daemon response" };
+}
+async function notifyDaemonSessionEvent(sessionId, event, spawnedBy) {
+  return daemonPost("/session-event", { sessionId, event, spawnedBy });
+}
+async function notifyDaemonClaudeAuthFailed(sessionId) {
+  return daemonPost("/session-event", { sessionId, event: "auth_failed" });
+}
+async function notifyDaemonTurnEvent(sessionId, event) {
+  return daemonPost("/session-event", { sessionId, event });
+}
+async function notifyDaemonBackgroundTasks(sessionId, backgroundTasks) {
+  return daemonPost("/session-event", { sessionId, event: "background_tasks", backgroundTasks });
+}
+function reportSessionEditToDaemon(edit) {
+  void daemonPost("/session-edit", edit).then((result) => {
+    if (result?.error) logger.logger.debug(`[CONTROL CLIENT] session-edit not recorded: ${result.error}`);
+  }).catch((error) => {
+    logger.logger.debug("[CONTROL CLIENT] session-edit failed:", error);
+  });
+}
+async function listDaemonPeers() {
+  const result = await daemonPost("/peers");
+  if (result?.error) {
+    const reason = String(result.error);
+    if (/404|Not Found/i.test(reason)) {
+      throw new Error("The running daemon does not support session peers; restart it on a CLI that does (`very-happy daemon start` after updating)");
+    }
+    throw new Error(reason);
+  }
+  return Array.isArray(result?.sessions) ? result.sessions : [];
+}
+async function stopDaemonHttp() {
+  await daemonPost("/stop");
+}
+async function pushClipboardViaDaemon(text, terminalId) {
+  const result = await daemonPost("/clipboard", { text, ...terminalId ? { terminalId } : {} });
+  if (result?.error && result.delivered === void 0) {
+    return { delivered: false, error: result.error };
+  }
+  return result;
+}
+async function pushFilePreviewViaDaemon(terminalId, path, mode = "file") {
+  const result = await daemonPost("/file-preview", { terminalId, path, mode });
+  if (result?.error) return { delivered: false, error: result.error };
+  return { delivered: result?.delivered === true, ...result?.delivered === true ? {} : { error: "preview was not delivered" } };
+}
+async function setTerminalTitleViaDaemon(terminalId, title, ifAbsent = false) {
+  const result = await daemonPost("/terminal-title", { terminalId, title, ifAbsent });
+  if (result?.error) {
+    return { ok: false, error: result.error };
+  }
+  return { ok: result?.status === "ok", error: result?.status === "ok" ? void 0 : "unexpected daemon response" };
+}
+async function checkIfDaemonRunningAndCleanupStaleState() {
+  const state = await persistence.readDaemonState();
+  if (!state) {
+    return false;
+  }
+  try {
+    process.kill(state.pid, 0);
+  } catch {
+    logger.logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+    await cleanupDaemonState();
+    return false;
+  }
+  if (state.httpPort) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${state.httpPort}/list`, {
+        method: "POST",
+        headers: daemonControlHeaders(state.controlToken),
+        body: "{}",
+        signal: AbortSignal.timeout(2e3)
+      });
+      if (response.ok) {
+        return true;
+      }
+    } catch {
+      logger.logger.debug(`[DAEMON RUN] PID ${state.pid} is alive but HTTP health check failed on port ${state.httpPort}, cleaning up stale state`);
+      await cleanupDaemonState();
+      return false;
+    }
+  }
+  return true;
+}
+async function isDaemonRunningCurrentlyInstalledHappyVersion() {
+  logger.logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
+  const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
+  if (!runningDaemon) {
+    logger.logger.debug("[DAEMON CONTROL] No daemon running, returning false");
+    return false;
+  }
+  const state = await persistence.readDaemonState();
+  if (!state) {
+    logger.logger.debug("[DAEMON CONTROL] No daemon state found, returning false");
+    return false;
+  }
+  const currentCliVersion = configuration.configuration.currentCliVersion;
+  logger.logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
+  return currentCliVersion === state.startedWithCliVersion;
+}
+async function cleanupDaemonState() {
+  try {
+    await persistence.clearDaemonState();
+    logger.logger.debug("[DAEMON RUN] Daemon state file removed");
+  } catch (error) {
+    logger.logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
+  }
+}
+async function stopDaemon() {
+  try {
+    const state = await persistence.readDaemonState();
+    if (!state) {
+      logger.logger.debug("No daemon state found");
+      return;
+    }
+    logger.logger.debug(`Stopping daemon with PID ${state.pid}`);
+    try {
+      await stopDaemonHttp();
+      await waitForProcessDeath(state.pid, 2e3);
+      logger.logger.debug("Daemon stopped gracefully via HTTP");
+      return;
+    } catch (error) {
+      logger.logger.debug("HTTP stop failed, will force kill", error);
+    }
+    try {
+      process.kill(state.pid, "SIGKILL");
+      logger.logger.debug("Force killed daemon");
+    } catch (error) {
+      logger.logger.debug("Daemon already dead");
+    }
+  } catch (error) {
+    logger.logger.debug("Error stopping daemon", error);
+  }
+}
+async function waitForProcessDeath(pid, timeout) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    try {
+      process.kill(pid, 0);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    } catch {
+      return;
+    }
+  }
+  throw new Error("Process did not die within timeout");
+}
+
+exports.checkIfDaemonRunningAndCleanupStaleState = checkIfDaemonRunningAndCleanupStaleState;
+exports.cleanupDaemonState = cleanupDaemonState;
+exports.isDaemonRunningCurrentlyInstalledHappyVersion = isDaemonRunningCurrentlyInstalledHappyVersion;
+exports.listDaemonPeers = listDaemonPeers;
+exports.listDaemonSessions = listDaemonSessions;
+exports.notifyDaemonBackgroundTasks = notifyDaemonBackgroundTasks;
+exports.notifyDaemonClaudeAuthFailed = notifyDaemonClaudeAuthFailed;
+exports.notifyDaemonSessionEvent = notifyDaemonSessionEvent;
+exports.notifyDaemonSessionStarted = notifyDaemonSessionStarted;
+exports.notifyDaemonTurnEvent = notifyDaemonTurnEvent;
+exports.pushClipboardViaDaemon = pushClipboardViaDaemon;
+exports.pushFilePreviewViaDaemon = pushFilePreviewViaDaemon;
+exports.reportSessionEditToDaemon = reportSessionEditToDaemon;
+exports.resumeDaemonSession = resumeDaemonSession;
+exports.setTerminalTitleViaDaemon = setTerminalTitleViaDaemon;
+exports.spawnDaemonSession = spawnDaemonSession;
+exports.stopDaemon = stopDaemon;
+exports.stopDaemonSession = stopDaemonSession;

package/dist/createSessionMetadata-BJxEnM-o.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+var os = require('node:os');
+var path = require('node:path');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var _package = require('./package-BwMrPwqH.cjs');
+
+const SPAWN_ORIGIN_TAG_MAX = 24;
+function spawnOriginTags(env = process.env, flavor = void 0) {
+  if (env.HAPPY_SESSION_VARIANT === "assistant" && flavor === "claude") return void 0;
+  const origin = (env.HAPPY_SPAWNED_BY ?? "").trim();
+  if (!origin) return void 0;
+  if (origin.length > SPAWN_ORIGIN_TAG_MAX) return void 0;
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(origin)) return void 0;
+  return [origin];
+}
+function isValidSpawnOrigin(value) {
+  return spawnOriginTags({ HAPPY_SPAWNED_BY: value }) !== void 0;
+}
+function createSessionMetadata(opts) {
+  const state = {
+    controlledByUser: false
+  };
+  const originTags = spawnOriginTags(process.env, opts.flavor);
+  const metadata = {
+    path: process.cwd(),
+    host: os.hostname(),
+    version: _package.packageJson.version,
+    os: os.platform(),
+    machineId: opts.machineId,
+    ...opts.teamOperationId ? { teamOperationId: opts.teamOperationId } : {},
+    homeDir: os.homedir(),
+    happyHomeDir: configuration.configuration.happyHomeDir,
+    happyLibDir: projectPath.projectPath(),
+    happyToolsDir: path.resolve(projectPath.projectPath(), "tools", "unpacked"),
+    startedFromDaemon: opts.startedBy === "daemon",
+    hostPid: process.pid,
+    startedBy: opts.startedBy || "terminal",
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: opts.flavor,
+    sandbox: opts.sandbox?.enabled ? opts.sandbox : null,
+    dangerouslySkipPermissions: opts.dangerouslySkipPermissions ?? null,
+    ...opts.parentSessionId ? { parentSessionId: opts.parentSessionId } : {},
+    ...opts.forkedFromMessageId ? { forkedFromMessageId: opts.forkedFromMessageId } : {},
+    ...opts.capabilities ? { capabilities: [...opts.capabilities] } : {},
+    // B-091/B-303: dispatched sessions carry their spawn origin as a tag
+    // from birth (see spawnOriginTags) — applies to every flavor the daemon
+    // can spawn, since HAPPY_SPAWNED_BY is exported flavor-independently.
+    ...originTags ? { tags: originTags } : {}
+  };
+  return { state, metadata };
+}
+
+exports.createSessionMetadata = createSessionMetadata;
+exports.isValidSpawnOrigin = isValidSpawnOrigin;
+exports.spawnOriginTags = spawnOriginTags;

package/dist/createSessionMetadata-CVVkGjxV.mjs

@@ -0,0 +1,54 @@
+import os from 'node:os';
+import { resolve } from 'node:path';
+import { c as configuration } from './configuration-RfeNjFmd.mjs';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { p as packageJson } from './package-BhaKlnxz.mjs';
+
+const SPAWN_ORIGIN_TAG_MAX = 24;
+function spawnOriginTags(env = process.env, flavor = void 0) {
+  if (env.HAPPY_SESSION_VARIANT === "assistant" && flavor === "claude") return void 0;
+  const origin = (env.HAPPY_SPAWNED_BY ?? "").trim();
+  if (!origin) return void 0;
+  if (origin.length > SPAWN_ORIGIN_TAG_MAX) return void 0;
+  if (!/^[a-z0-9][a-z0-9_-]*$/.test(origin)) return void 0;
+  return [origin];
+}
+function isValidSpawnOrigin(value) {
+  return spawnOriginTags({ HAPPY_SPAWNED_BY: value }) !== void 0;
+}
+function createSessionMetadata(opts) {
+  const state = {
+    controlledByUser: false
+  };
+  const originTags = spawnOriginTags(process.env, opts.flavor);
+  const metadata = {
+    path: process.cwd(),
+    host: os.hostname(),
+    version: packageJson.version,
+    os: os.platform(),
+    machineId: opts.machineId,
+    ...opts.teamOperationId ? { teamOperationId: opts.teamOperationId } : {},
+    homeDir: os.homedir(),
+    happyHomeDir: configuration.happyHomeDir,
+    happyLibDir: projectPath(),
+    happyToolsDir: resolve(projectPath(), "tools", "unpacked"),
+    startedFromDaemon: opts.startedBy === "daemon",
+    hostPid: process.pid,
+    startedBy: opts.startedBy || "terminal",
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now(),
+    flavor: opts.flavor,
+    sandbox: opts.sandbox?.enabled ? opts.sandbox : null,
+    dangerouslySkipPermissions: opts.dangerouslySkipPermissions ?? null,
+    ...opts.parentSessionId ? { parentSessionId: opts.parentSessionId } : {},
+    ...opts.forkedFromMessageId ? { forkedFromMessageId: opts.forkedFromMessageId } : {},
+    ...opts.capabilities ? { capabilities: [...opts.capabilities] } : {},
+    // B-091/B-303: dispatched sessions carry their spawn origin as a tag
+    // from birth (see spawnOriginTags) — applies to every flavor the daemon
+    // can spawn, since HAPPY_SPAWNED_BY is exported flavor-independently.
+    ...originTags ? { tags: originTags } : {}
+  };
+  return { state, metadata };
+}
+
+export { createSessionMetadata as c, isValidSpawnOrigin as i, spawnOriginTags as s };

package/dist/defaultPermissionMode-BnxJPVHT.mjs

@@ -0,0 +1,4 @@
+const DEFAULT_CLAUDE_PERMISSION_MODE = "default";
+const DEFAULT_CODEX_PERMISSION_MODE = "default";
+
+export { DEFAULT_CLAUDE_PERMISSION_MODE as D, DEFAULT_CODEX_PERMISSION_MODE as a };

package/dist/defaultPermissionMode-CxmTXUQR.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+const DEFAULT_CLAUDE_PERMISSION_MODE = "default";
+const DEFAULT_CODEX_PERMISSION_MODE = "default";
+
+exports.DEFAULT_CLAUDE_PERMISSION_MODE = DEFAULT_CLAUDE_PERMISSION_MODE;
+exports.DEFAULT_CODEX_PERMISSION_MODE = DEFAULT_CODEX_PERMISSION_MODE;

package/dist/detectCLI-CSGMlV51.mjs

@@ -0,0 +1,58 @@
+import { execSync } from 'child_process';
+import os from 'os';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+function detectCLIAvailability() {
+  const isWindows = os.platform() === "win32";
+  if (isWindows) {
+    return detectWindows();
+  }
+  return detectPosix();
+}
+function commandExists(command) {
+  try {
+    execSync(`command -v ${command} >/dev/null 2>&1`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function commandExistsWindows(name) {
+  try {
+    execSync(`powershell -NoProfile -Command "Get-Command ${name} -ErrorAction SilentlyContinue"`, { stdio: "ignore", windowsHide: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+const SAFE_COMMAND_NAME = /^[A-Za-z0-9._-]+$/;
+function commandOnPath(name) {
+  if (!SAFE_COMMAND_NAME.test(name)) return false;
+  return os.platform() === "win32" ? commandExistsWindows(name) : commandExists(name);
+}
+function detectPosix() {
+  const claude = commandExists("claude");
+  const codex = commandExists("codex");
+  const gemini = commandExists("gemini");
+  const openclawCommand = commandExists("openclaw");
+  const openclawConfig = existsSync(join(os.homedir(), ".openclaw", "openclaw.json"));
+  const openclawEnv = !!process.env.OPENCLAW_GATEWAY_URL;
+  const openclaw = openclawCommand || openclawConfig || openclawEnv;
+  const pi = commandExists("pi") && commandExists("pi-acp");
+  return { claude, codex, gemini, openclaw, pi, detectedAt: Date.now() };
+}
+function detectWindows() {
+  const checkCommand = commandExistsWindows;
+  const claude = checkCommand("claude");
+  const codex = checkCommand("codex");
+  const gemini = checkCommand("gemini");
+  const openclawCommand = checkCommand("openclaw");
+  const openclawConfig = existsSync(join(process.env.USERPROFILE || os.homedir(), ".openclaw", "openclaw.json"));
+  const openclawEnv = !!process.env.OPENCLAW_GATEWAY_URL;
+  const openclaw = openclawCommand || openclawConfig || openclawEnv;
+  const pi = checkCommand("pi") && checkCommand("pi-acp");
+  return { claude, codex, gemini, openclaw, pi, detectedAt: Date.now() };
+}
+
+export { commandOnPath as c, detectCLIAvailability as d };

package/dist/detectCLI-DR9ZaN6B.cjs

@@ -0,0 +1,61 @@
+'use strict';
+
+var child_process = require('child_process');
+var os = require('os');
+var fs = require('fs');
+var path = require('path');
+
+function detectCLIAvailability() {
+  const isWindows = os.platform() === "win32";
+  if (isWindows) {
+    return detectWindows();
+  }
+  return detectPosix();
+}
+function commandExists(command) {
+  try {
+    child_process.execSync(`command -v ${command} >/dev/null 2>&1`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function commandExistsWindows(name) {
+  try {
+    child_process.execSync(`powershell -NoProfile -Command "Get-Command ${name} -ErrorAction SilentlyContinue"`, { stdio: "ignore", windowsHide: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+const SAFE_COMMAND_NAME = /^[A-Za-z0-9._-]+$/;
+function commandOnPath(name) {
+  if (!SAFE_COMMAND_NAME.test(name)) return false;
+  return os.platform() === "win32" ? commandExistsWindows(name) : commandExists(name);
+}
+function detectPosix() {
+  const claude = commandExists("claude");
+  const codex = commandExists("codex");
+  const gemini = commandExists("gemini");
+  const openclawCommand = commandExists("openclaw");
+  const openclawConfig = fs.existsSync(path.join(os.homedir(), ".openclaw", "openclaw.json"));
+  const openclawEnv = !!process.env.OPENCLAW_GATEWAY_URL;
+  const openclaw = openclawCommand || openclawConfig || openclawEnv;
+  const pi = commandExists("pi") && commandExists("pi-acp");
+  return { claude, codex, gemini, openclaw, pi, detectedAt: Date.now() };
+}
+function detectWindows() {
+  const checkCommand = commandExistsWindows;
+  const claude = checkCommand("claude");
+  const codex = checkCommand("codex");
+  const gemini = checkCommand("gemini");
+  const openclawCommand = checkCommand("openclaw");
+  const openclawConfig = fs.existsSync(path.join(process.env.USERPROFILE || os.homedir(), ".openclaw", "openclaw.json"));
+  const openclawEnv = !!process.env.OPENCLAW_GATEWAY_URL;
+  const openclaw = openclawCommand || openclawConfig || openclawEnv;
+  const pi = checkCommand("pi") && checkCommand("pi-acp");
+  return { claude, codex, gemini, openclaw, pi, detectedAt: Date.now() };
+}
+
+exports.commandOnPath = commandOnPath;
+exports.detectCLIAvailability = detectCLIAvailability;