@zonease/happy 0.6.38 → 0.6.40

package/dist/diagnose-B3D1a_v0.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+var chalk = require('chalk');
+var workflowReports = require('./workflowReports-BEWuQesA.cjs');
+var workflowCommon = require('./workflowCommon-Bl568-rt.cjs');
+require('node:path');
+require('node:fs/promises');
+
+function printDiagnoseHelp() {
+  console.log(`
+${chalk.bold("happy diagnose")} - Diagnosis evidence helpers
+
+${chalk.bold("Usage:")}
+  happy diagnose remote --host <host> [options]
+
+${chalk.bold("Options:")}
+  --host <host>           SSH host alias or user@host
+  --service <name>        Service/container name for docker logs
+  --keyword <text>        Keyword to grep in logs
+  --since <duration>      Log window, e.g. "2 hours ago" or "2026-05-13 10:00"
+  --health-url <url>      Health endpoint to curl on the host
+  --out <path>            Write the evidence pack to a markdown file
+  --json                  Print machine-readable JSON
+  -h, --help              Show this help
+`);
+}
+async function handleDiagnoseCommand(args) {
+  const action = args[0];
+  if (!action || action === "-h" || action === "--help") {
+    printDiagnoseHelp();
+    return;
+  }
+  if (action !== "remote") {
+    throw new Error(`Unknown diagnose command: ${action}. Use "happy diagnose remote".`);
+  }
+  const parsed = workflowCommon.parseWorkflowArgs(args.slice(1), /* @__PURE__ */ new Set(["--host", "--service", "--keyword", "--since", "--health-url", "--out"]));
+  if (workflowCommon.booleanFlag(parsed, "--help") || workflowCommon.booleanFlag(parsed, "-h")) {
+    printDiagnoseHelp();
+    return;
+  }
+  const host = workflowCommon.stringFlag(parsed, "--host") ?? parsed.positionals[0];
+  if (!host) {
+    throw new Error("--host is required.");
+  }
+  const input = {
+    host,
+    service: workflowCommon.stringFlag(parsed, "--service"),
+    keyword: workflowCommon.stringFlag(parsed, "--keyword"),
+    since: workflowCommon.stringFlag(parsed, "--since") ?? "2 hours ago",
+    healthUrl: workflowCommon.stringFlag(parsed, "--health-url")
+  };
+  const report = workflowReports.buildRemoteDiagnoseReport(input);
+  if (workflowCommon.booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify({ ...input, report }, null, 2));
+    return;
+  }
+  await workflowCommon.printOrWriteOutput(report, workflowCommon.stringFlag(parsed, "--out"));
+}
+
+exports.handleDiagnoseCommand = handleDiagnoseCommand;

package/dist/diagnose-CuRKXxt1.mjs

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { a as buildRemoteDiagnoseReport } from './workflowReports-Dd8-4-8f.mjs';
+import { p as parseWorkflowArgs, b as booleanFlag, s as stringFlag, a as printOrWriteOutput } from './workflowCommon-B0d01Y_a.mjs';
+import 'node:path';
+import 'node:fs/promises';
+
+function printDiagnoseHelp() {
+  console.log(`
+${chalk.bold("happy diagnose")} - Diagnosis evidence helpers
+
+${chalk.bold("Usage:")}
+  happy diagnose remote --host <host> [options]
+
+${chalk.bold("Options:")}
+  --host <host>           SSH host alias or user@host
+  --service <name>        Service/container name for docker logs
+  --keyword <text>        Keyword to grep in logs
+  --since <duration>      Log window, e.g. "2 hours ago" or "2026-05-13 10:00"
+  --health-url <url>      Health endpoint to curl on the host
+  --out <path>            Write the evidence pack to a markdown file
+  --json                  Print machine-readable JSON
+  -h, --help              Show this help
+`);
+}
+async function handleDiagnoseCommand(args) {
+  const action = args[0];
+  if (!action || action === "-h" || action === "--help") {
+    printDiagnoseHelp();
+    return;
+  }
+  if (action !== "remote") {
+    throw new Error(`Unknown diagnose command: ${action}. Use "happy diagnose remote".`);
+  }
+  const parsed = parseWorkflowArgs(args.slice(1), /* @__PURE__ */ new Set(["--host", "--service", "--keyword", "--since", "--health-url", "--out"]));
+  if (booleanFlag(parsed, "--help") || booleanFlag(parsed, "-h")) {
+    printDiagnoseHelp();
+    return;
+  }
+  const host = stringFlag(parsed, "--host") ?? parsed.positionals[0];
+  if (!host) {
+    throw new Error("--host is required.");
+  }
+  const input = {
+    host,
+    service: stringFlag(parsed, "--service"),
+    keyword: stringFlag(parsed, "--keyword"),
+    since: stringFlag(parsed, "--since") ?? "2 hours ago",
+    healthUrl: stringFlag(parsed, "--health-url")
+  };
+  const report = buildRemoteDiagnoseReport(input);
+  if (booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify({ ...input, report }, null, 2));
+    return;
+  }
+  await printOrWriteOutput(report, stringFlag(parsed, "--out"));
+}
+
+export { handleDiagnoseCommand };

package/dist/doctor-BQGLhrcI.cjs

@@ -0,0 +1,214 @@
+'use strict';
+
+var chalk = require('chalk');
+var logger = require('./persistence-CBTtC_dm.cjs');
+var controlClient = require('./controlClient-B23M-WPp.cjs');
+var doctor = require('./doctor-C08m5Z9f.cjs');
+var fs = require('node:fs');
+var path = require('node:path');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+require('node:fs/promises');
+require('node:os');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('fs');
+require('path');
+require('ps-list');
+require('cross-spawn');
+require('url');
+
+function getEnvironmentInfo() {
+  return {
+    PWD: process.env.PWD,
+    HAPPY_HOME_DIR: process.env.HAPPY_HOME_DIR,
+    HAPPY_SERVER_URL: process.env.HAPPY_SERVER_URL,
+    HAPPY_PROJECT_ROOT: process.env.HAPPY_PROJECT_ROOT,
+    DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING: process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING,
+    NODE_ENV: process.env.NODE_ENV,
+    DEBUG: process.env.DEBUG,
+    workingDirectory: process.cwd(),
+    processArgv: process.argv,
+    happyDir: logger.configuration?.happyHomeDir,
+    serverUrl: logger.configuration?.serverUrl,
+    logsDir: logger.configuration?.logsDir,
+    processPid: process.pid,
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    user: process.env.USER,
+    home: process.env.HOME,
+    shell: process.env.SHELL,
+    terminal: process.env.TERM
+  };
+}
+function getLogFiles(logDir) {
+  if (!fs.existsSync(logDir)) {
+    return [];
+  }
+  try {
+    return fs.readdirSync(logDir).filter((file) => file.endsWith(".log")).map((file) => {
+      const path$1 = path.join(logDir, file);
+      const stats = 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 runDoctorCommand(filter) {
+  if (!filter) {
+    filter = "all";
+  }
+  console.log(chalk.bold.cyan("\n\u{1FA7A} Happy AI CLI Doctor\n"));
+  if (filter === "all") {
+    console.log(chalk.bold("\u{1F4CB} Basic Information"));
+    console.log(`Happy AI CLI Version: ${chalk.green(logger.packageJson.version)}`);
+    console.log(`Platform: ${chalk.green(process.platform)} ${process.arch}`);
+    console.log(`Node.js Version: ${chalk.green(process.version)}`);
+    console.log("");
+    console.log(chalk.bold("\u{1F527} Daemon Spawn Diagnostics"));
+    const projectRoot = projectPath.projectPath();
+    const wrapperPath = path.join(projectRoot, "bin", "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: ${fs.existsSync(wrapperPath) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+    console.log(`CLI Exists: ${fs.existsSync(cliEntrypoint) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+    console.log("");
+    console.log(chalk.bold("\u2699\uFE0F  Configuration"));
+    console.log(`Happy AI Home: ${chalk.blue(logger.configuration.happyHomeDir)}`);
+    console.log(`Server URL: ${chalk.blue(logger.configuration.serverUrl)}`);
+    console.log(`Logs Dir: ${chalk.blue(logger.configuration.logsDir)}`);
+    console.log(chalk.bold("\n\u{1F30D} Environment Variables"));
+    const env = getEnvironmentInfo();
+    console.log(`HAPPY_HOME_DIR: ${env.HAPPY_HOME_DIR ? chalk.green(env.HAPPY_HOME_DIR) : chalk.gray("not set")}`);
+    console.log(`HAPPY_SERVER_URL: ${env.HAPPY_SERVER_URL ? chalk.green(env.HAPPY_SERVER_URL) : chalk.gray("not set")}`);
+    console.log(`DANGEROUSLY_LOG_TO_SERVER: ${env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING ? chalk.yellow("ENABLED") : chalk.gray("not set")}`);
+    console.log(`DEBUG: ${env.DEBUG ? chalk.green(env.DEBUG) : chalk.gray("not set")}`);
+    console.log(`NODE_ENV: ${env.NODE_ENV ? chalk.green(env.NODE_ENV) : chalk.gray("not set")}`);
+    try {
+      const settings = await logger.readSettings();
+      console.log(chalk.bold("\n\u{1F4C4} Settings (settings.json):"));
+      console.log(chalk.gray(JSON.stringify(settings, null, 2)));
+    } 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{1F510} Authentication"));
+    try {
+      const credentials = await logger.readCredentials();
+      if (credentials) {
+        console.log(chalk.green("\u2713 Authenticated (credentials found)"));
+      } 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 logger.readDaemonState();
+    if (isRunning && state) {
+      console.log(chalk.green("\u2713 Daemon is running"));
+      console.log(`  PID: ${state.pid}`);
+      console.log(`  Started: ${new Date(state.startTime).toLocaleString()}`);
+      console.log(`  CLI Version: ${state.startedWithCliVersion}`);
+      if (state.httpPort) {
+        console.log(`  HTTP Port: ${state.httpPort}`);
+      }
+    } else if (state && !isRunning) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Daemon state exists but process not running (stale)"));
+    } else {
+      console.log(chalk.red("\u274C Daemon is not running"));
+    }
+    if (state) {
+      console.log(chalk.bold("\n\u{1F4C4} Daemon State:"));
+      console.log(chalk.blue(`Location: ${logger.configuration.daemonStateFile}`));
+      console.log(chalk.gray(JSON.stringify(state, null, 2)));
+    }
+    const allProcesses = await doctor.findAllHappyProcesses();
+    if (allProcesses.length > 0) {
+      console.log(chalk.bold("\n\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(({ pid, command }) => {
+          const color = type === "current" ? chalk.green : type.startsWith("dev") ? chalk.cyan : type.includes("daemon") ? chalk.blue : chalk.gray;
+          console.log(`  ${color(`PID ${pid}`)}: ${chalk.gray(command)}`);
+        });
+      });
+    } else {
+      console.log(chalk.red("\u274C No happy processes found"));
+    }
+    if (filter === "all" && allProcesses.length > 1) {
+      console.log(chalk.bold("\n\u{1F4A1} Process Management"));
+      console.log(chalk.gray("To clean up runaway processes: happy doctor clean"));
+    }
+  } catch (error) {
+    console.log(chalk.red("\u274C Error checking daemon status"));
+  }
+  if (filter === "all") {
+    console.log(chalk.bold("\n\u{1F4DD} Log Files"));
+    const allLogs = getLogFiles(logger.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{1F41B} Support & Bug Reports"));
+    console.log(`Report issues: ${chalk.blue("https://github.com/ZonEaseTech/happy-wfs/issues")}`);
+    console.log(`Documentation: ${chalk.blue("https://github.com/ZonEaseTech/happy-wfs")}`);
+  }
+  console.log(chalk.green("\n\u2705 Doctor diagnosis complete!\n"));
+}
+
+exports.getEnvironmentInfo = getEnvironmentInfo;
+exports.runDoctorCommand = runDoctorCommand;

package/dist/doctor-C08m5Z9f.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+var psList = require('ps-list');
+var spawn = require('cross-spawn');
+
+async function findAllHappyProcesses() {
+  try {
+    const processes = await psList();
+    const allProcesses = [];
+    for (const proc of processes) {
+      const cmd = proc.cmd || "";
+      const name = proc.name || "";
+      const isHappy = name.includes("happy") || name === "node" && (cmd.includes("happy-cli") || cmd.includes("dist/index.mjs")) || cmd.includes("happy.mjs") || cmd.includes("@zonease/happy") || cmd.includes("tsx") && cmd.includes("src/index.ts") && cmd.includes("happy-cli");
+      if (!isHappy) continue;
+      let type = "unknown";
+      if (proc.pid === process.pid) {
+        type = "current";
+      } else if (cmd.includes("--version")) {
+        type = cmd.includes("tsx") ? "dev-daemon-version-check" : "daemon-version-check";
+      } else if (cmd.includes("daemon start-sync") || cmd.includes("daemon start")) {
+        type = cmd.includes("tsx") ? "dev-daemon" : "daemon";
+      } else if (cmd.includes("--started-by daemon")) {
+        type = cmd.includes("tsx") ? "dev-daemon-spawned" : "daemon-spawned-session";
+      } else if (cmd.includes("doctor")) {
+        type = cmd.includes("tsx") ? "dev-doctor" : "doctor";
+      } else if (cmd.includes("--yolo")) {
+        type = "dev-session";
+      } else {
+        type = cmd.includes("tsx") ? "dev-related" : "user-session";
+      }
+      allProcesses.push({ pid: proc.pid, command: cmd || name, type });
+    }
+    return allProcesses;
+  } catch (error) {
+    return [];
+  }
+}
+async function findRunawayHappyProcesses() {
+  const allProcesses = await findAllHappyProcesses();
+  return allProcesses.filter(
+    (p) => p.pid !== process.pid && (p.type === "daemon" || p.type === "dev-daemon" || p.type === "daemon-spawned-session" || p.type === "dev-daemon-spawned" || p.type === "daemon-version-check" || p.type === "dev-daemon-version-check")
+  ).map((p) => ({ pid: p.pid, command: p.command }));
+}
+async function killRunawayHappyProcesses() {
+  const runawayProcesses = await findRunawayHappyProcesses();
+  const errors = [];
+  let killed = 0;
+  for (const { pid, command } of runawayProcesses) {
+    try {
+      console.log(`Killing runaway process PID ${pid}: ${command}`);
+      if (process.platform === "win32") {
+        const result = spawn.sync("taskkill", ["/F", "/PID", pid.toString()], { stdio: "pipe" });
+        if (result.error) throw result.error;
+        if (result.status !== 0) throw new Error(`taskkill exited with code ${result.status}`);
+      } else {
+        process.kill(pid, "SIGTERM");
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        const processes = await psList();
+        const stillAlive = processes.find((p) => p.pid === pid);
+        if (stillAlive) {
+          console.log(`Process PID ${pid} ignored SIGTERM, using SIGKILL`);
+          process.kill(pid, "SIGKILL");
+        }
+      }
+      console.log(`Successfully killed runaway process PID ${pid}`);
+      killed++;
+    } catch (error) {
+      const errorMessage = error.message;
+      errors.push({ pid, error: errorMessage });
+      console.log(`Failed to kill process PID ${pid}: ${errorMessage}`);
+    }
+  }
+  return { killed, errors };
+}
+
+exports.findAllHappyProcesses = findAllHappyProcesses;
+exports.findRunawayHappyProcesses = findRunawayHappyProcesses;
+exports.killRunawayHappyProcesses = killRunawayHappyProcesses;

package/dist/doctor-CU4JLGQ1.mjs

@@ -0,0 +1,211 @@
+import chalk from 'chalk';
+import { p as packageJson, c as configuration, a as readSettings, r as readCredentials, j as readDaemonState } from './persistence-DKfF81pd.mjs';
+import { checkIfDaemonRunningAndCleanupStaleState } from './controlClient-DB5tDU7V.mjs';
+import { findAllHappyProcesses } from './doctor-ON7pN5G5.mjs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import 'node:fs/promises';
+import 'node:os';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'fs';
+import 'path';
+import 'ps-list';
+import 'cross-spawn';
+import 'url';
+
+function getEnvironmentInfo() {
+  return {
+    PWD: process.env.PWD,
+    HAPPY_HOME_DIR: process.env.HAPPY_HOME_DIR,
+    HAPPY_SERVER_URL: process.env.HAPPY_SERVER_URL,
+    HAPPY_PROJECT_ROOT: process.env.HAPPY_PROJECT_ROOT,
+    DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING: process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING,
+    NODE_ENV: process.env.NODE_ENV,
+    DEBUG: process.env.DEBUG,
+    workingDirectory: process.cwd(),
+    processArgv: process.argv,
+    happyDir: configuration?.happyHomeDir,
+    serverUrl: configuration?.serverUrl,
+    logsDir: configuration?.logsDir,
+    processPid: process.pid,
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    user: process.env.USER,
+    home: process.env.HOME,
+    shell: process.env.SHELL,
+    terminal: process.env.TERM
+  };
+}
+function getLogFiles(logDir) {
+  if (!existsSync(logDir)) {
+    return [];
+  }
+  try {
+    return readdirSync(logDir).filter((file) => file.endsWith(".log")).map((file) => {
+      const path = join(logDir, file);
+      const stats = statSync(path);
+      return { file, path, modified: stats.mtime };
+    }).sort((a, b) => b.modified.getTime() - a.modified.getTime());
+  } catch {
+    return [];
+  }
+}
+async function runDoctorCommand(filter) {
+  if (!filter) {
+    filter = "all";
+  }
+  console.log(chalk.bold.cyan("\n\u{1FA7A} Happy AI CLI Doctor\n"));
+  if (filter === "all") {
+    console.log(chalk.bold("\u{1F4CB} Basic Information"));
+    console.log(`Happy AI CLI Version: ${chalk.green(packageJson.version)}`);
+    console.log(`Platform: ${chalk.green(process.platform)} ${process.arch}`);
+    console.log(`Node.js Version: ${chalk.green(process.version)}`);
+    console.log("");
+    console.log(chalk.bold("\u{1F527} Daemon Spawn Diagnostics"));
+    const projectRoot = projectPath();
+    const wrapperPath = join(projectRoot, "bin", "happy.mjs");
+    const cliEntrypoint = 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: ${existsSync(wrapperPath) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+    console.log(`CLI Exists: ${existsSync(cliEntrypoint) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+    console.log("");
+    console.log(chalk.bold("\u2699\uFE0F  Configuration"));
+    console.log(`Happy AI Home: ${chalk.blue(configuration.happyHomeDir)}`);
+    console.log(`Server URL: ${chalk.blue(configuration.serverUrl)}`);
+    console.log(`Logs Dir: ${chalk.blue(configuration.logsDir)}`);
+    console.log(chalk.bold("\n\u{1F30D} Environment Variables"));
+    const env = getEnvironmentInfo();
+    console.log(`HAPPY_HOME_DIR: ${env.HAPPY_HOME_DIR ? chalk.green(env.HAPPY_HOME_DIR) : chalk.gray("not set")}`);
+    console.log(`HAPPY_SERVER_URL: ${env.HAPPY_SERVER_URL ? chalk.green(env.HAPPY_SERVER_URL) : chalk.gray("not set")}`);
+    console.log(`DANGEROUSLY_LOG_TO_SERVER: ${env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING ? chalk.yellow("ENABLED") : chalk.gray("not set")}`);
+    console.log(`DEBUG: ${env.DEBUG ? chalk.green(env.DEBUG) : chalk.gray("not set")}`);
+    console.log(`NODE_ENV: ${env.NODE_ENV ? chalk.green(env.NODE_ENV) : chalk.gray("not set")}`);
+    try {
+      const settings = await readSettings();
+      console.log(chalk.bold("\n\u{1F4C4} Settings (settings.json):"));
+      console.log(chalk.gray(JSON.stringify(settings, null, 2)));
+    } 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{1F510} Authentication"));
+    try {
+      const credentials = await readCredentials();
+      if (credentials) {
+        console.log(chalk.green("\u2713 Authenticated (credentials found)"));
+      } 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 checkIfDaemonRunningAndCleanupStaleState();
+    const state = await readDaemonState();
+    if (isRunning && state) {
+      console.log(chalk.green("\u2713 Daemon is running"));
+      console.log(`  PID: ${state.pid}`);
+      console.log(`  Started: ${new Date(state.startTime).toLocaleString()}`);
+      console.log(`  CLI Version: ${state.startedWithCliVersion}`);
+      if (state.httpPort) {
+        console.log(`  HTTP Port: ${state.httpPort}`);
+      }
+    } else if (state && !isRunning) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Daemon state exists but process not running (stale)"));
+    } else {
+      console.log(chalk.red("\u274C Daemon is not running"));
+    }
+    if (state) {
+      console.log(chalk.bold("\n\u{1F4C4} Daemon State:"));
+      console.log(chalk.blue(`Location: ${configuration.daemonStateFile}`));
+      console.log(chalk.gray(JSON.stringify(state, null, 2)));
+    }
+    const allProcesses = await findAllHappyProcesses();
+    if (allProcesses.length > 0) {
+      console.log(chalk.bold("\n\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(({ pid, command }) => {
+          const color = type === "current" ? chalk.green : type.startsWith("dev") ? chalk.cyan : type.includes("daemon") ? chalk.blue : chalk.gray;
+          console.log(`  ${color(`PID ${pid}`)}: ${chalk.gray(command)}`);
+        });
+      });
+    } else {
+      console.log(chalk.red("\u274C No happy processes found"));
+    }
+    if (filter === "all" && allProcesses.length > 1) {
+      console.log(chalk.bold("\n\u{1F4A1} Process Management"));
+      console.log(chalk.gray("To clean up runaway processes: happy doctor clean"));
+    }
+  } catch (error) {
+    console.log(chalk.red("\u274C Error checking daemon status"));
+  }
+  if (filter === "all") {
+    console.log(chalk.bold("\n\u{1F4DD} Log Files"));
+    const allLogs = getLogFiles(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{1F41B} Support & Bug Reports"));
+    console.log(`Report issues: ${chalk.blue("https://github.com/ZonEaseTech/happy-wfs/issues")}`);
+    console.log(`Documentation: ${chalk.blue("https://github.com/ZonEaseTech/happy-wfs")}`);
+  }
+  console.log(chalk.green("\n\u2705 Doctor diagnosis complete!\n"));
+}
+
+export { getEnvironmentInfo, runDoctorCommand };