@zonease/happy 0.6.38 → 0.6.39

package/dist/controlClient-CM_QcJnB.mjs

@@ -0,0 +1,159 @@
+import { l as logger, j as readDaemonState, n as clearDaemonState } from './persistence-BFjvtUad.mjs';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import 'node:fs/promises';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'chalk';
+import 'url';
+
+async function daemonPost(path, body) {
+  const state = await readDaemonState();
+  if (!state?.httpPort) {
+    const errorMessage = "No daemon running, no state file found";
+    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.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",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body || {}),
+      // Mostly increased for stress test
+      signal: AbortSignal.timeout(timeout)
+    });
+    if (!response.ok) {
+      const errorMessage = `Request failed: ${path}, HTTP ${response.status}`;
+      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.debug(`[CONTROL CLIENT] ${errorMessage}`);
+    return {
+      error: errorMessage
+    };
+  }
+}
+async function notifyDaemonSessionStarted(sessionId, metadata) {
+  return await daemonPost("/session-started", {
+    sessionId,
+    metadata
+  });
+}
+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 stopDaemonHttp() {
+  await daemonPost("/stop");
+}
+async function checkIfDaemonRunningAndCleanupStaleState() {
+  const state = await readDaemonState();
+  if (!state) {
+    return false;
+  }
+  try {
+    process.kill(state.pid, 0);
+    return true;
+  } catch {
+    logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+    await cleanupDaemonState();
+    return false;
+  }
+}
+async function isDaemonRunningCurrentlyInstalledHappyVersion() {
+  logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
+  const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
+  if (!runningDaemon) {
+    logger.debug("[DAEMON CONTROL] No daemon running, returning false");
+    return false;
+  }
+  const state = await readDaemonState();
+  if (!state) {
+    logger.debug("[DAEMON CONTROL] No daemon state found, returning false");
+    return false;
+  }
+  try {
+    const packageJsonPath = join(projectPath(), "package.json");
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const currentCliVersion = packageJson.version;
+    logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
+    return currentCliVersion === state.startedWithCliVersion;
+  } catch (error) {
+    logger.debug("[DAEMON CONTROL] Error checking daemon version", error);
+    return false;
+  }
+}
+async function cleanupDaemonState() {
+  try {
+    await clearDaemonState();
+    logger.debug("[DAEMON RUN] Daemon state file removed");
+  } catch (error) {
+    logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
+  }
+}
+async function stopDaemon() {
+  try {
+    const state = await readDaemonState();
+    if (!state) {
+      logger.debug("No daemon state found");
+      return;
+    }
+    logger.debug(`Stopping daemon with PID ${state.pid}`);
+    try {
+      await stopDaemonHttp();
+      await waitForProcessDeath(state.pid, 2e3);
+      logger.debug("Daemon stopped gracefully via HTTP");
+      return;
+    } catch (error) {
+      logger.debug("HTTP stop failed, will force kill", error);
+    }
+    try {
+      process.kill(state.pid, "SIGKILL");
+      logger.debug("Force killed daemon");
+    } catch (error) {
+      logger.debug("Daemon already dead");
+    }
+  } catch (error) {
+    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");
+}
+
+export { checkIfDaemonRunningAndCleanupStaleState, cleanupDaemonState, isDaemonRunningCurrentlyInstalledHappyVersion, listDaemonSessions, notifyDaemonSessionStarted, stopDaemon, stopDaemonHttp, stopDaemonSession };

package/dist/controlClient-DZMIsKsT.cjs

@@ -0,0 +1,168 @@
+'use strict';
+
+var logger = require('./persistence-JLUn_Nou.cjs');
+var projectPath = require('./projectPath-ChLhdOyt.cjs');
+var fs = require('fs');
+var path = require('path');
+require('node:fs/promises');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('chalk');
+require('url');
+
+async function daemonPost(path, body) {
+  const state = await logger.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",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body || {}),
+      // Mostly increased for stress test
+      signal: AbortSignal.timeout(timeout)
+    });
+    if (!response.ok) {
+      const errorMessage = `Request failed: ${path}, HTTP ${response.status}`;
+      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
+    };
+  }
+}
+async function notifyDaemonSessionStarted(sessionId, metadata) {
+  return await daemonPost("/session-started", {
+    sessionId,
+    metadata
+  });
+}
+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 stopDaemonHttp() {
+  await daemonPost("/stop");
+}
+async function checkIfDaemonRunningAndCleanupStaleState() {
+  const state = await logger.readDaemonState();
+  if (!state) {
+    return false;
+  }
+  try {
+    process.kill(state.pid, 0);
+    return true;
+  } catch {
+    logger.logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+    await cleanupDaemonState();
+    return false;
+  }
+}
+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 logger.readDaemonState();
+  if (!state) {
+    logger.logger.debug("[DAEMON CONTROL] No daemon state found, returning false");
+    return false;
+  }
+  try {
+    const packageJsonPath = path.join(projectPath.projectPath(), "package.json");
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    const currentCliVersion = packageJson.version;
+    logger.logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
+    return currentCliVersion === state.startedWithCliVersion;
+  } catch (error) {
+    logger.logger.debug("[DAEMON CONTROL] Error checking daemon version", error);
+    return false;
+  }
+}
+async function cleanupDaemonState() {
+  try {
+    await logger.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 logger.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.listDaemonSessions = listDaemonSessions;
+exports.notifyDaemonSessionStarted = notifyDaemonSessionStarted;
+exports.stopDaemon = stopDaemon;
+exports.stopDaemonHttp = stopDaemonHttp;
+exports.stopDaemonSession = stopDaemonSession;

package/dist/deviceExec-CU1R9CRb.cjs

@@ -0,0 +1,84 @@
+'use strict';
+
+var axios = require('axios');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var auth = require('./auth-BIleVCw0.cjs');
+
+function resolveMachineKey(credentials, dataEncryptionKey) {
+  if (credentials.encryption.type === "legacy") {
+    return { key: credentials.encryption.secret, variant: "legacy" };
+  }
+  if (!dataEncryptionKey) return null;
+  const blob = logger.decodeBase64(dataEncryptionKey);
+  if (blob.length < 1 || blob[0] !== 0) return null;
+  const opened = auth.decryptWithEphemeralKey(blob.slice(1), credentials.encryption.machineKey);
+  return opened ? { key: opened, variant: "dataKey" } : null;
+}
+async function fetchMachines(credentials) {
+  const response = await axios.get(
+    `${logger.configuration.serverUrl}/v1/machines`,
+    { headers: { Authorization: `Bearer ${credentials.token}` }, timeout: 15e3 }
+  );
+  const data = response.data;
+  return Array.isArray(data) ? data : data.machines ?? [];
+}
+async function listDevices(credentials) {
+  const rows = await fetchMachines(credentials);
+  return rows.map((row) => {
+    const resolved = resolveMachineKey(credentials, row.dataEncryptionKey);
+    let metadata = null;
+    if (resolved && row.metadata) {
+      try {
+        metadata = logger.decrypt(resolved.key, resolved.variant, logger.decodeBase64(row.metadata));
+      } catch {
+        metadata = null;
+      }
+    }
+    return {
+      id: row.id,
+      name: row.displayName || metadata?.displayName || metadata?.host || row.id.slice(0, 12),
+      description: row.description ?? null,
+      platform: metadata?.platform ?? null,
+      active: row.active,
+      lastActiveAt: row.activeAt ?? row.lastActiveAt ?? 0
+    };
+  });
+}
+async function deviceExec(socket, credentials, deviceId, command, options = {}) {
+  const row = options.skipMachineLookup ? null : await (async () => {
+    const rows = await fetchMachines(credentials);
+    const found = rows.find((candidate) => candidate.id === deviceId);
+    if (!found) {
+      throw new Error(`Device ${deviceId} not found`);
+    }
+    if (!found.active) {
+      throw new Error(`Device ${deviceId} is offline`);
+    }
+    return found;
+  })();
+  const resolved = options.deviceKeyBase64 ? { key: logger.decodeBase64(options.deviceKeyBase64), variant: options.deviceKeyVariant ?? "dataKey" } : resolveMachineKey(credentials, row.dataEncryptionKey);
+  if (!resolved) {
+    throw new Error(`Cannot resolve encryption key for device ${deviceId}. Re-select the device in the app.`);
+  }
+  const timeout = options.timeout ?? 6e4;
+  const params = logger.encodeBase64(logger.encrypt(resolved.key, resolved.variant, {
+    command,
+    cwd: options.cwd,
+    timeout
+  }));
+  const answer = await socket.timeout(timeout + 5e3).emitWithAck("rpc-call", {
+    method: `${deviceId}:bash`,
+    params
+  });
+  if (!answer?.ok) {
+    throw new Error(answer?.error || "Device RPC failed");
+  }
+  const decrypted = logger.decrypt(resolved.key, resolved.variant, logger.decodeBase64(answer.result));
+  if (!decrypted) {
+    throw new Error("Failed to decrypt device response");
+  }
+  return decrypted;
+}
+
+exports.deviceExec = deviceExec;
+exports.listDevices = listDevices;

package/dist/deviceExec-D93AOVV4.mjs

@@ -0,0 +1,81 @@
+import axios from 'axios';
+import { e as decodeBase64, f as encodeBase64, g as encrypt, h as decrypt, c as configuration } from './persistence-BFjvtUad.mjs';
+import { decryptWithEphemeralKey } from './auth-BE8dD20T.mjs';
+
+function resolveMachineKey(credentials, dataEncryptionKey) {
+  if (credentials.encryption.type === "legacy") {
+    return { key: credentials.encryption.secret, variant: "legacy" };
+  }
+  if (!dataEncryptionKey) return null;
+  const blob = decodeBase64(dataEncryptionKey);
+  if (blob.length < 1 || blob[0] !== 0) return null;
+  const opened = decryptWithEphemeralKey(blob.slice(1), credentials.encryption.machineKey);
+  return opened ? { key: opened, variant: "dataKey" } : null;
+}
+async function fetchMachines(credentials) {
+  const response = await axios.get(
+    `${configuration.serverUrl}/v1/machines`,
+    { headers: { Authorization: `Bearer ${credentials.token}` }, timeout: 15e3 }
+  );
+  const data = response.data;
+  return Array.isArray(data) ? data : data.machines ?? [];
+}
+async function listDevices(credentials) {
+  const rows = await fetchMachines(credentials);
+  return rows.map((row) => {
+    const resolved = resolveMachineKey(credentials, row.dataEncryptionKey);
+    let metadata = null;
+    if (resolved && row.metadata) {
+      try {
+        metadata = decrypt(resolved.key, resolved.variant, decodeBase64(row.metadata));
+      } catch {
+        metadata = null;
+      }
+    }
+    return {
+      id: row.id,
+      name: row.displayName || metadata?.displayName || metadata?.host || row.id.slice(0, 12),
+      description: row.description ?? null,
+      platform: metadata?.platform ?? null,
+      active: row.active,
+      lastActiveAt: row.activeAt ?? row.lastActiveAt ?? 0
+    };
+  });
+}
+async function deviceExec(socket, credentials, deviceId, command, options = {}) {
+  const row = options.skipMachineLookup ? null : await (async () => {
+    const rows = await fetchMachines(credentials);
+    const found = rows.find((candidate) => candidate.id === deviceId);
+    if (!found) {
+      throw new Error(`Device ${deviceId} not found`);
+    }
+    if (!found.active) {
+      throw new Error(`Device ${deviceId} is offline`);
+    }
+    return found;
+  })();
+  const resolved = options.deviceKeyBase64 ? { key: decodeBase64(options.deviceKeyBase64), variant: options.deviceKeyVariant ?? "dataKey" } : resolveMachineKey(credentials, row.dataEncryptionKey);
+  if (!resolved) {
+    throw new Error(`Cannot resolve encryption key for device ${deviceId}. Re-select the device in the app.`);
+  }
+  const timeout = options.timeout ?? 6e4;
+  const params = encodeBase64(encrypt(resolved.key, resolved.variant, {
+    command,
+    cwd: options.cwd,
+    timeout
+  }));
+  const answer = await socket.timeout(timeout + 5e3).emitWithAck("rpc-call", {
+    method: `${deviceId}:bash`,
+    params
+  });
+  if (!answer?.ok) {
+    throw new Error(answer?.error || "Device RPC failed");
+  }
+  const decrypted = decrypt(resolved.key, resolved.variant, decodeBase64(answer.result));
+  if (!decrypted) {
+    throw new Error("Failed to decrypt device response");
+  }
+  return decrypted;
+}
+
+export { deviceExec as d, listDevices as l };

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-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;