very-happy-cli 0.2.158 → 0.2.160

package/dist/doctor-D2YJ-Yn2.cjs

@@ -0,0 +1,395 @@
+'use strict';
+
+var chalk = require('chalk');
+var configuration = require('./configuration-BSYpcPwE.cjs');
+var persistence = require('./persistence-yKTH3-5X.cjs');
+var controlClient = require('./controlClient-Bcwv3D21.cjs');
+var doctor$1 = require('./doctor-u46qYYKX.cjs');
+var node_fs = require('node:fs');
+var path = require('node:path');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var _package = require('./package-BwMrPwqH.cjs');
+var doctorReadiness = require('./doctorReadiness-BCZGcN0a.cjs');
+var authRelay = require('./authRelay-BdYkC1Po.cjs');
+var cliUpdate = require('./cliUpdate-DsKXPFYp.cjs');
+var node_child_process = require('node:child_process');
+
+function shareSafeProcessLine(process2) {
+  return `PID ${process2.pid}: command arguments hidden for privacy`;
+}
+function shareSafeDaemonState(state) {
+  const { controlToken, ...shareSafeState } = state;
+  return {
+    ...shareSafeState,
+    controlAuthentication: controlToken ? "configured" : "legacy"
+  };
+}
+function shareSafeEnvironmentInfo(env = process.env, runtime = process) {
+  const knownNodeEnvironments = /* @__PURE__ */ new Set(["development", "production", "test"]);
+  const nodeEnvironment = env.NODE_ENV ? knownNodeEnvironments.has(env.NODE_ENV) ? env.NODE_ENV : "custom" : "not set";
+  return {
+    happyHomeDirConfigured: Boolean(env.HAPPY_HOME_DIR),
+    happyVariantConfigured: Boolean(env.HAPPY_VARIANT),
+    customServerUrlConfigured: Boolean(env.HAPPY_SERVER_URL),
+    projectRootConfigured: Boolean(env.HAPPY_PROJECT_ROOT),
+    remoteDebugLoggingEnabled: Boolean(env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING),
+    debugEnabled: Boolean(env.DEBUG),
+    nodeEnvironment,
+    processPid: runtime.pid,
+    nodeVersion: runtime.version,
+    platform: runtime.platform,
+    arch: runtime.arch,
+    shellConfigured: Boolean(env.SHELL),
+    terminalConfigured: Boolean(env.TERM)
+  };
+}
+
+const NPM_SAFE_ARG = /^[A-Za-z0-9@=.,+/_-]+$/;
+function globalPrefixForPackage(packageDir) {
+  if (!path.isAbsolute(packageDir)) return null;
+  const dir = path.resolve(packageDir);
+  const nodeModules = path.dirname(dir);
+  const lib = path.dirname(nodeModules);
+  const prefix = path.dirname(lib);
+  if (path.basename(dir) !== "very-happy-cli" || path.basename(nodeModules) !== "node_modules" || path.basename(lib) !== "lib") return null;
+  if (prefix === lib || path.resolve(prefix) === "/" || !NPM_SAFE_ARG.test(prefix)) return null;
+  return prefix;
+}
+function packageDirForBin(realBin) {
+  const packageDir = path.dirname(path.dirname(realBin));
+  return path.basename(path.dirname(realBin)) === "bin" && path.basename(packageDir) === "very-happy-cli" ? packageDir : null;
+}
+function installLocationWarnings(facts, version) {
+  const warnings = [];
+  const running = path.resolve(facts.runningPackageDir);
+  const packages = [...new Set(facts.onPath.map(packageDirForBin).filter((dir) => Boolean(dir)).map((dir) => path.resolve(dir)))];
+  if (packages.length > 1) {
+    warnings.push(`Found ${packages.length} very-happy installs on PATH (first one wins): ${packages.join(", ")}. Updating one does not update the others; remove the ones you do not use.`);
+  }
+  if (packages[0] && packages[0] !== running) {
+    warnings.push(`The very-happy command runs ${packages[0]}, but this CLI runs from ${running}.`);
+  }
+  const prefix = globalPrefixForPackage(running);
+  if (prefix && facts.npmGlobalPrefix && path.resolve(facts.npmGlobalPrefix) !== path.resolve(prefix)) {
+    const target = version ? `very-happy-cli@${version}` : "very-happy-cli@latest";
+    warnings.push(`npm install -g writes to ${facts.npmGlobalPrefix}, but this CLI runs from ${prefix}; a plain update will not take effect. Update with: npm install -g --prefix ${prefix} --allow-scripts=very-happy-cli,node-pty ${target} && very-happy daemon start`);
+  }
+  return warnings;
+}
+function gatherInstallLocationFacts(runningPackageDir, env = process.env) {
+  if (process.platform === "win32") return null;
+  const onPath = [];
+  for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+    if (!dir) continue;
+    try {
+      const candidate = path.join(dir, "very-happy");
+      if (!node_fs.statSync(candidate).isFile()) continue;
+      const real = node_fs.realpathSync(candidate);
+      if (!onPath.includes(real)) onPath.push(real);
+    } catch {
+    }
+  }
+  let npmGlobalPrefix = null;
+  try {
+    const result = node_child_process.spawnSync("npm", ["prefix", "-g"], { encoding: "utf8", timeout: 5e3, env });
+    const out = result.status === 0 ? result.stdout.trim() : "";
+    npmGlobalPrefix = out && path.isAbsolute(out) && !out.includes("\n") ? out : null;
+  } catch {
+  }
+  return { runningPackageDir, onPath, npmGlobalPrefix };
+}
+
+function printCliUpdateStatus(state) {
+  const installed = configuration.configuration.currentCliVersion;
+  const running = state?.startedWithCliVersion ?? null;
+  const summary = cliUpdate.deriveLocalCliUpdateSummary(installed, running, state?.cliUpdate);
+  console.log(`  Installed CLI:  ${installed}`);
+  console.log(`  Running daemon: ${running ?? "not running"}`);
+  if (state?.cliUpdate?.recommendedVersion) console.log(`  Recommended:    ${state.cliUpdate.recommendedVersion}`);
+  if (state?.cliUpdate?.minimumVersion) console.log(`  Minimum:        ${state.cliUpdate.minimumVersion}`);
+  if (summary.daemonMismatch) {
+    console.log(chalk.yellow("  \u26A0 Installed CLI and running daemon differ; run `very-happy daemon start` to hand over safely."));
+  }
+  if (summary.installedStatus === "required") {
+    console.log(chalk.red("  \u2717 This CLI is below the relay minimum supported version."));
+  } else if (summary.installedStatus === "available") {
+    console.log(chalk.yellow("  \u25B3 A newer CLI is available."));
+  }
+  if (summary.installCommand) console.log(`  Update: ${summary.installCommand}`);
+  const facts = gatherInstallLocationFacts(projectPath.projectPath());
+  for (const warning of facts ? installLocationWarnings(facts, state?.cliUpdate?.recommendedVersion ?? void 0) : []) {
+    console.log(chalk.yellow(`  \u26A0 ${warning}`));
+  }
+}
+function getEnvironmentInfo() {
+  return shareSafeEnvironmentInfo();
+}
+function getLogFiles(logDir) {
+  if (!node_fs.existsSync(logDir)) {
+    return [];
+  }
+  try {
+    return node_fs.readdirSync(logDir).filter((file) => file.endsWith(".log")).map((file) => {
+      const path$1 = path.join(logDir, file);
+      const stats = node_fs.statSync(path$1);
+      return { file, path: path$1, modified: stats.mtime };
+    }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
+  } catch {
+    return [];
+  }
+}
+async function runDoctorDaemon() {
+  console.log(chalk.bold("\n\u{1F916} Daemon Status"));
+  try {
+    const isRunning = await controlClient.checkIfDaemonRunningAndCleanupStaleState();
+    const state = await persistence.readDaemonState();
+    if (isRunning && state) {
+      console.log(chalk.green("\u2713 Daemon is running"));
+      console.log(`  PID:     ${state.pid}`);
+      console.log(`  Port:    ${state.httpPort}`);
+      console.log(`  Started: ${new Date(state.startTime).toLocaleString()}`);
+      printCliUpdateStatus(state);
+      console.log(`  Relay:   ${state.serverUrl ?? "unknown (started by an older CLI)"}`);
+      console.log(`  Web UI:  ${state.webappUrl ?? "unknown (started by an older CLI)"}`);
+      console.log(`  Claude:  ${state.claudeCredentialSource ?? "not detected at daemon start"}`);
+      if (!doctorReadiness.daemonEndpointsMatch(state.serverUrl, state.webappUrl, configuration.configuration.serverUrl, configuration.configuration.webappUrl)) {
+        console.log(chalk.red("  \u2717 Running daemon endpoints differ from this shell; run `very-happy daemon start` to restart it safely."));
+      }
+    } else if (state && !isRunning) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Daemon state exists but process not running (stale)"));
+      printCliUpdateStatus(state);
+    } else {
+      console.log(chalk.red("\u274C Daemon is not running"));
+      printCliUpdateStatus(null);
+    }
+    if (state) {
+      console.log(chalk.bold("\n\u{1F4C4} Daemon State:"));
+      console.log(chalk.blue(`Location: ${configuration.configuration.daemonStateFile}`));
+      console.log(chalk.gray(JSON.stringify(shareSafeDaemonState(state), null, 2)));
+    }
+  } catch (error) {
+    console.log(chalk.red("\u274C Error checking daemon status"));
+  }
+  console.log(chalk.gray("\nRun `very-happy doctor` for full diagnostics.\n"));
+}
+async function runDoctorCommand() {
+  console.log(chalk.bold.cyan("\n\u{1FA7A} Happy CLI Doctor\n"));
+  try {
+    const allProcesses = await doctor$1.findAllHappyProcesses();
+    if (allProcesses.length > 0) {
+      console.log(chalk.bold("\u{1F50D} All Happy CLI Processes"));
+      const grouped = allProcesses.reduce((groups, process2) => {
+        if (!groups[process2.type]) groups[process2.type] = [];
+        groups[process2.type].push(process2);
+        return groups;
+      }, {});
+      Object.entries(grouped).forEach(([type, processes]) => {
+        const typeLabels = {
+          "current": "\u{1F4CD} Current Process",
+          "daemon": "\u{1F916} Daemon",
+          "daemon-version-check": "\u{1F50D} Daemon Version Check (stuck)",
+          "daemon-spawned-session": "\u{1F517} Daemon-Spawned Sessions",
+          "user-session": "\u{1F464} User Sessions",
+          "dev-daemon": "\u{1F6E0}\uFE0F  Dev Daemon",
+          "dev-daemon-version-check": "\u{1F6E0}\uFE0F  Dev Daemon Version Check (stuck)",
+          "dev-session": "\u{1F6E0}\uFE0F  Dev Sessions",
+          "dev-doctor": "\u{1F6E0}\uFE0F  Dev Doctor",
+          "dev-related": "\u{1F6E0}\uFE0F  Dev Related",
+          "doctor": "\u{1FA7A} Doctor",
+          "unknown": "\u2753 Unknown"
+        };
+        console.log(chalk.blue(`
+${typeLabels[type] || type}:`));
+        processes.forEach((process2) => {
+          const color = type === "current" ? chalk.green : type.startsWith("dev") ? chalk.cyan : type.includes("daemon") ? chalk.blue : chalk.gray;
+          console.log(`  ${color(shareSafeProcessLine(process2))}`);
+        });
+      });
+      if (allProcesses.length > 1) {
+        console.log(chalk.bold("\n\u{1F4A1} Process Management"));
+        console.log(chalk.gray("To clean up runaway processes: very-happy doctor clean"));
+      }
+    } else {
+      console.log(chalk.red("\u274C No happy processes found"));
+    }
+  } catch (error) {
+    console.log(chalk.red("\u274C Error listing processes"));
+  }
+  console.log(chalk.bold("\n\u{1F4DD} Log Files"));
+  const allLogs = getLogFiles(configuration.configuration.logsDir);
+  if (allLogs.length > 0) {
+    const daemonLogs = allLogs.filter(({ file }) => file.includes("daemon"));
+    const regularLogs = allLogs.filter(({ file }) => !file.includes("daemon"));
+    if (regularLogs.length > 0) {
+      console.log(chalk.blue("\nRecent Logs:"));
+      const logsToShow = regularLogs.slice(0, 10);
+      logsToShow.forEach(({ file, path, modified }) => {
+        console.log(`  ${chalk.green(file)} - ${modified.toLocaleString()}`);
+        console.log(chalk.gray(`    ${path}`));
+      });
+      if (regularLogs.length > 10) {
+        console.log(chalk.gray(`  ... and ${regularLogs.length - 10} more log files`));
+      }
+    }
+    if (daemonLogs.length > 0) {
+      console.log(chalk.blue("\nDaemon Logs:"));
+      const daemonLogsToShow = daemonLogs.slice(0, 5);
+      daemonLogsToShow.forEach(({ file, path, modified }) => {
+        console.log(`  ${chalk.green(file)} - ${modified.toLocaleString()}`);
+        console.log(chalk.gray(`    ${path}`));
+      });
+      if (daemonLogs.length > 5) {
+        console.log(chalk.gray(`  ... and ${daemonLogs.length - 5} more daemon log files`));
+      }
+    } else {
+      console.log(chalk.yellow("\nNo daemon log files found"));
+    }
+  } else {
+    console.log(chalk.yellow("No log files found"));
+  }
+  console.log(chalk.bold("\n\u{1F527} Daemon Spawn Diagnostics"));
+  const projectRoot = projectPath.projectPath();
+  const wrapperPath = path.join(projectRoot, "bin", "very-happy.mjs");
+  const cliEntrypoint = path.join(projectRoot, "dist", "index.mjs");
+  console.log(`Project Root: ${chalk.blue(projectRoot)}`);
+  console.log(`Wrapper Script: ${chalk.blue(wrapperPath)}`);
+  console.log(`CLI Entrypoint: ${chalk.blue(cliEntrypoint)}`);
+  console.log(`Wrapper Exists: ${node_fs.existsSync(wrapperPath) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+  console.log(`CLI Exists: ${node_fs.existsSync(cliEntrypoint) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+  console.log(chalk.bold("\n\u{1F30D} Environment Variables"));
+  const env = getEnvironmentInfo();
+  console.log(`HAPPY_HOME_DIR: ${env.happyHomeDirConfigured ? chalk.green("set (path hidden here)") : chalk.gray("not set")}`);
+  console.log(`HAPPY_SERVER_URL: ${env.customServerUrlConfigured ? chalk.green("set (resolved origin shown below)") : chalk.gray("not set")}`);
+  console.log(`DANGEROUSLY_LOG_TO_SERVER: ${env.remoteDebugLoggingEnabled ? chalk.yellow("ENABLED") : chalk.gray("not set")}`);
+  console.log(`DEBUG: ${env.debugEnabled ? chalk.green("enabled (value hidden)") : chalk.gray("not set")}`);
+  console.log(`NODE_ENV: ${chalk.green(env.nodeEnvironment)}`);
+  try {
+    const settings = await persistence.readSettings();
+    console.log(chalk.bold("\n\u{1F4C4} Settings (share-safe summary):"));
+    console.log(chalk.gray(JSON.stringify(doctorReadiness.shareableSettingsSummary(settings), null, 2)));
+    console.log(chalk.gray("Unknown fields, commands, arguments, paths, and credential-like values are omitted."));
+  } catch (error) {
+    console.log(chalk.bold("\n\u{1F4C4} Settings:"));
+    console.log(chalk.red("\u274C Failed to read settings"));
+  }
+  console.log(chalk.bold("\n\u{1F41B} Support & Bug Reports"));
+  console.log(`Report issues: ${chalk.blue("https://github.com/Mereithhh/very-happy/issues")}`);
+  console.log(`Documentation: ${chalk.blue("https://github.com/Mereithhh/very-happy/tree/main/docs")}`);
+  console.log(chalk.bold("\n\u{1F4CB} Basic Information"));
+  console.log(`Happy CLI Version: ${chalk.green(_package.packageJson.version)}`);
+  console.log(`Platform: ${chalk.green(process.platform)} ${process.arch}`);
+  console.log(`Node.js Version: ${chalk.green(process.version)}`);
+  console.log(chalk.bold("\n\u2699\uFE0F  Configuration"));
+  console.log(`Happy Home: ${chalk.blue(configuration.configuration.happyHomeDir)}`);
+  console.log(`Configured server URL: ${chalk.blue(configuration.configuration.serverUrl)}`);
+  console.log(`Configured approval UI: ${chalk.blue(configuration.configuration.webappUrl)}`);
+  console.log(`Logs Dir: ${chalk.blue(configuration.configuration.logsDir)}`);
+  const readiness = doctorReadiness.collectRuntimeReadiness();
+  console.log(chalk.bold("\n\u{1F9ED} First-use Readiness"));
+  if (readiness.node.supported) {
+    console.log(chalk.green(`\u2713 Node.js ${readiness.node.version} (supported: ${doctorReadiness.SUPPORTED_NODE_LABEL})`));
+  } else {
+    console.log(chalk.red(`\u274C Node.js ${readiness.node.version} is unsupported; install Node.js ${doctorReadiness.SUPPORTED_NODE_LABEL}`));
+  }
+  if (!readiness.tmux.available) {
+    console.log(chalk.yellow("\u25CB tmux not found \u2014 Web terminals use a non-persistent direct shell"));
+    console.log(chalk.gray("  Install tmux for reconnectable terminals; use tmux 3.2+ for the optional Claude mirror."));
+  } else if (!readiness.tmux.supportsSessionEnv) {
+    console.log(chalk.yellow(`\u25B3 ${readiness.tmux.version ?? "tmux found"} \u2014 durable terminals work, but 3.2+ is required for the optional Claude mirror`));
+  } else {
+    console.log(chalk.green(`\u2713 ${readiness.tmux.version ?? "tmux 3.2+"} \u2014 durable Web terminals and the optional Claude mirror are available`));
+  }
+  const availableAgents = readiness.agents.filter((agent) => agent.available);
+  console.log(chalk.green("\u2713 Claude structured runtime: bundled Agent SDK"));
+  const currentClaudeCredentials = doctorReadiness.resolveClaudeCredentialReadiness();
+  if (currentClaudeCredentials.configured) {
+    console.log(chalk.green(`\u2713 Claude credential source in this process: ${currentClaudeCredentials.source}`));
+    console.log(chalk.gray("  Restart the daemon after changing its credentials or service-manager environment."));
+  } else {
+    console.log(chalk.yellow("\u25CB No Claude credential source detected in this process"));
+    console.log(chalk.gray("  Set ANTHROPIC_API_KEY or a supported cloud provider for the daemon user, then restart it."));
+    console.log(chalk.gray("  OS-keychain credentials cannot be verified here; see /docs/configuration#claude-credentials."));
+  }
+  console.log(chalk.gray("  An external claude command is only needed for native terminal/mirror use."));
+  try {
+    const { resolveAgentHomesForCli } = await Promise.resolve().then(function () { return require('./agentHome-CboCeKWq.cjs'); });
+    const { describeAgentHome } = await Promise.resolve().then(function () { return require('./index-Bu5Zi_a9.cjs'); });
+    const homes = await resolveAgentHomesForCli();
+    console.log(chalk.green(`\u2713 Claude config dir: ${describeAgentHome(homes.claudeConfigDir)}`));
+    console.log(chalk.green(`\u2713 Codex home: ${describeAgentHome(homes.codexHome)}`));
+    console.log(chalk.gray("  Resolved from settings.json, then your login shell, then the daemon environment; pin with `very-happy agent-home`."));
+  } catch {
+    console.log(chalk.yellow("\u25CB Could not resolve the Claude/Codex home directories"));
+  }
+  if (availableAgents.length === 0) {
+    console.log(chalk.yellow("\u25CB No external agent command found on this daemon PATH"));
+    console.log(chalk.gray("  Codex, Gemini, OpenCode, OpenClaw, and native Claude terminal paths need their local command or gateway."));
+    console.log(chalk.gray("  Bundled structured Claude and plain Web terminals remain available."));
+  } else {
+    console.log(chalk.green(`\u2713 External agent command${availableAgents.length === 1 ? "" : "s"}: ${availableAgents.map(doctorReadiness.toolProbeLabel).join(", ")}`));
+  }
+  const piProbe = readiness.agents.find((agent) => agent.command === "pi");
+  if (piProbe?.available && !readiness.piAdapter.available) {
+    console.log(chalk.yellow("\u25CB pi found, but the pi-acp adapter is not on PATH \u2014 `very-happy pi` and spawning pi from the Web need it"));
+    console.log(chalk.gray("  Install it for the daemon user: npm install -g pi-acp@0.0.33"));
+  }
+  console.log(chalk.bold("\n\u{1F510} Authentication"));
+  let authenticated = false;
+  try {
+    const credentials = await persistence.readCredentials();
+    if (credentials) {
+      const relayProblem = authRelay.credentialRelayProblem(credentials.authServerUrl, configuration.configuration.serverUrl);
+      if (relayProblem) {
+        console.log(chalk.red(`\u2717 Not paired to the configured relay: ${relayProblem}`));
+        console.log(chalk.gray("  Use a separate HAPPY_HOME_DIR or run `very-happy auth login --force`."));
+      } else {
+        authenticated = true;
+        console.log(chalk.green("\u2713 Authenticated to the configured relay"));
+      }
+    } else {
+      console.log(chalk.yellow("\u26A0\uFE0F  Not authenticated (no credentials)"));
+    }
+  } catch (error) {
+    console.log(chalk.red("\u274C Error reading credentials"));
+  }
+  console.log(chalk.bold("\n\u{1F916} Daemon Status"));
+  try {
+    const isRunning = await controlClient.checkIfDaemonRunningAndCleanupStaleState();
+    const state = await persistence.readDaemonState();
+    const summary = doctorReadiness.daemonReadiness(authenticated, isRunning, Boolean(state));
+    if (summary.level === "ready" && state) {
+      console.log(chalk.green(summary.message));
+      console.log(`  PID:     ${state.pid}`);
+      console.log(`  Port:    ${state.httpPort}`);
+      console.log(`  Started: ${new Date(state.startTime).toLocaleString()}`);
+      printCliUpdateStatus(state);
+      console.log(`  Relay:   ${state.serverUrl ?? "unknown (started by an older CLI)"}`);
+      console.log(`  Web UI:  ${state.webappUrl ?? "unknown (started by an older CLI)"}`);
+      console.log(`  Claude:  ${state.claudeCredentialSource ?? "not detected at daemon start"}`);
+      if (!doctorReadiness.daemonEndpointsMatch(state.serverUrl, state.webappUrl, configuration.configuration.serverUrl, configuration.configuration.webappUrl)) {
+        console.log(chalk.red("  \u2717 Running daemon endpoints differ from the configured endpoints; run `very-happy daemon start` to restart it."));
+      }
+    } else {
+      console.log(chalk.yellow(summary.message));
+    }
+    if (state) {
+      console.log(chalk.bold("\n\u{1F4C4} Daemon State:"));
+      console.log(chalk.blue(`Location: ${configuration.configuration.daemonStateFile}`));
+      console.log(chalk.gray(JSON.stringify(shareSafeDaemonState(state), null, 2)));
+    }
+  } catch (error) {
+    console.log(chalk.red("\u274C Error checking daemon status"));
+  }
+  console.log(chalk.green("\n\u2705 Doctor diagnosis complete!\n"));
+}
+
+var doctor = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getEnvironmentInfo: getEnvironmentInfo,
+    runDoctorCommand: runDoctorCommand,
+    runDoctorDaemon: runDoctorDaemon
+});
+
+exports.doctor = doctor;
+exports.getEnvironmentInfo = getEnvironmentInfo;
+exports.globalPrefixForPackage = globalPrefixForPackage;