@zonease/happy 0.6.38 → 0.6.40

package/dist/task-wNX1N2i4.mjs

@@ -0,0 +1,165 @@
+import chalk from 'chalk';
+import { resolve } from 'node:path';
+import { r as readCredentials } from './persistence-DKfF81pd.mjs';
+import { r as runSessionList } from './sessionList-CgAYZpNj.mjs';
+import { r as runSessionSummary } from './sessionSummary-DCWQoaDP.mjs';
+import { p as parseWorkflowArgs, s as stringFlag, b as booleanFlag, n as numberFlag, a as printOrWriteOutput } from './workflowCommon-B0d01Y_a.mjs';
+import 'node:fs/promises';
+import 'node:fs';
+import 'node:os';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'fs';
+import 'axios';
+import './auth-DxJ3VvrX.mjs';
+import 'qrcode-terminal';
+import './time-DgsBLJA_.mjs';
+import './browser-AoVGRX7y.mjs';
+import 'open';
+import 'react';
+import 'ink';
+import './sessionKeyCache-B6cGadYL.mjs';
+
+function printTaskHelp() {
+  console.log(`
+${chalk.bold("happy task")} - Agent handoff helpers
+
+${chalk.bold("Usage:")}
+  happy task brief --session <sessionId> [options]
+  happy task brief <sessionId> [options]
+  happy task brief --recent [--project <path>] [options]
+
+${chalk.bold("Options:")}
+  --session <id>       Happy session ID to summarize
+  --recent             Pick the most recent session, optionally filtered by --project
+  --project <path>     Project path filter for --recent
+  --limit <n>          Raw messages to compact (default: 200)
+  --max-turns <n>      Compact turns to include (default: 80)
+  --text-limit <n>     Max chars per text block (default: 800)
+  --out <path>         Write the brief to a markdown file
+  --json               Print machine-readable JSON
+  -h, --help           Show this help
+`);
+}
+function collectSessionText(summary) {
+  const chunks = [];
+  if (summary.storedSummary) chunks.push(summary.storedSummary);
+  for (const turn of summary.turns) {
+    if (turn.user?.text) chunks.push(turn.user.text);
+    for (const text of turn.assistantTexts) chunks.push(text.text);
+  }
+  return chunks.join("\n");
+}
+function extractMatchingLines(text, patterns, limit) {
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.replace(/^[-*]\s*/, "").trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    if (patterns.some((pattern) => pattern.test(trimmed))) {
+      seen.add(trimmed);
+      lines.push(trimmed);
+    }
+    if (lines.length >= limit) break;
+  }
+  return lines;
+}
+function bulletList(lines, fallback) {
+  if (lines.length === 0) return `- ${fallback}`;
+  return lines.map((line) => `- ${line}`).join("\n");
+}
+function buildBriefMarkdown(summary, source) {
+  const text = collectSessionText(summary);
+  const done = extractMatchingLines(text, [/完成|已实现|通过|passed|fixed|implemented|verified/i], 6);
+  const blockers = extractMatchingLines(text, [/失败|阻塞|blocked|failed|error|E401|unrelated/i], 6);
+  const next = extractMatchingLines(text, [/继续|下一步|TODO|todo|next|publish|发布|验证|verify/i], 6);
+  return `# Happy Task Brief
+
+- Source: ${source}
+- Session: \`${summary.sessionId}\`
+- Active: ${summary.active ? "yes" : "no"}
+- Agent: ${summary.agent.name ?? "(unknown)"}${summary.agent.model ? ` / ${summary.agent.model}` : ""}
+- Machine: ${summary.machine.name ?? summary.machine.id ?? "(unknown)"}
+- Path: ${summary.path ?? "(unknown)"}
+- Updated: ${new Date(summary.updatedAt).toISOString()}
+
+## Stored Summary
+
+${summary.storedSummary ?? "(none)"}
+
+## Recent Conversation
+
+${summary.summaryText}
+
+## Done / Evidence
+
+${bulletList(done, "No explicit completion evidence detected in the compact window.")}
+
+## Blockers / Risks
+
+${bulletList(blockers, "No explicit blocker detected in the compact window.")}
+
+## Suggested Next Actions
+
+${bulletList(next, "Continue from the latest user request and verify before reporting completion.")}
+
+## Continuation Prompt
+
+Continue session \`${summary.sessionId}\` from this brief. Preserve existing user changes, inspect the repository rules before editing, implement only the requested scope, run focused verification, and summarize changed files plus test results in Chinese.
+`;
+}
+function findRecentSession(sessions, projectPath) {
+  if (!projectPath) return sessions[0];
+  const resolved = resolve(projectPath);
+  return sessions.find((session) => {
+    if (!session.path) return false;
+    const path = resolve(session.path);
+    return path === resolved || path.startsWith(`${resolved}/`) || resolved.startsWith(`${path}/`);
+  });
+}
+async function handleTaskCommand(args) {
+  const action = args[0];
+  if (!action || action === "-h" || action === "--help") {
+    printTaskHelp();
+    return;
+  }
+  if (action !== "brief") {
+    throw new Error(`Unknown task command: ${action}. Use "happy task brief".`);
+  }
+  const parsed = parseWorkflowArgs(args.slice(1), /* @__PURE__ */ new Set(["--session", "--project", "--limit", "--max-turns", "--text-limit", "--out"]));
+  const credentials = await readCredentials();
+  if (!credentials) {
+    throw new Error('No happy credentials found. Run "happy auth login" first.');
+  }
+  let sessionId = stringFlag(parsed, "--session") ?? parsed.positionals[0];
+  let source = "session";
+  if (!sessionId && booleanFlag(parsed, "--recent")) {
+    const result = await runSessionList(credentials, { status: "all", limit: 150 });
+    const recent = findRecentSession(result.sessions, stringFlag(parsed, "--project"));
+    if (!recent) {
+      throw new Error("No matching recent session found.");
+    }
+    sessionId = recent.sessionId;
+    source = "recent";
+  }
+  if (!sessionId) {
+    throw new Error('Session ID required. Use "happy task brief --session <id>" or "--recent".');
+  }
+  const input = {
+    sessionId,
+    limit: numberFlag(parsed, "--limit"),
+    maxTurns: numberFlag(parsed, "--max-turns"),
+    textLimit: numberFlag(parsed, "--text-limit"),
+    includeTools: true
+  };
+  const summary = await runSessionSummary(credentials, input);
+  const brief = buildBriefMarkdown(summary, source);
+  if (booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify({ source, summary, brief }, null, 2));
+    return;
+  }
+  await printOrWriteOutput(brief, stringFlag(parsed, "--out"));
+}
+
+export { handleTaskCommand };

package/dist/time-Bj2HRkKH.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+async function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount) {
+  let maxDelayRet = minDelay + (maxDelay - minDelay) / maxFailureCount * Math.min(currentFailureCount, maxFailureCount);
+  return Math.round(Math.random() * maxDelayRet);
+}
+function createBackoff(opts) {
+  return async (callback) => {
+    let currentFailureCount = 0;
+    const minDelay = 250;
+    const maxDelay = 1e3;
+    const maxFailureCount = 50;
+    while (true) {
+      try {
+        return await callback();
+      } catch (e) {
+        if (currentFailureCount < maxFailureCount) {
+          currentFailureCount++;
+        }
+        let waitForRequest = exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount);
+        await delay(waitForRequest);
+      }
+    }
+  };
+}
+let backoff = createBackoff();
+
+exports.backoff = backoff;
+exports.delay = delay;
+exports.exponentialBackoffDelay = exponentialBackoffDelay;

package/dist/time-DgsBLJA_.mjs

@@ -0,0 +1,29 @@
+async function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount) {
+  let maxDelayRet = minDelay + (maxDelay - minDelay) / maxFailureCount * Math.min(currentFailureCount, maxFailureCount);
+  return Math.round(Math.random() * maxDelayRet);
+}
+function createBackoff(opts) {
+  return async (callback) => {
+    let currentFailureCount = 0;
+    const minDelay = 250;
+    const maxDelay = 1e3;
+    const maxFailureCount = 50;
+    while (true) {
+      try {
+        return await callback();
+      } catch (e) {
+        if (currentFailureCount < maxFailureCount) {
+          currentFailureCount++;
+        }
+        let waitForRequest = exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount);
+        await delay(waitForRequest);
+      }
+    }
+  };
+}
+let backoff = createBackoff();
+
+export { backoff as b, delay as d, exponentialBackoffDelay as e };

package/dist/trimIdent-4gvk9Wk6.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+function trimIdent(text) {
+  const lines = text.split("\n");
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines.shift();
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  const minSpaces = lines.reduce((min, line) => {
+    if (line.trim() === "") {
+      return min;
+    }
+    const leadingSpaces = line.match(/^\s*/)[0].length;
+    return Math.min(min, leadingSpaces);
+  }, Infinity);
+  const trimmedLines = lines.map((line) => line.slice(minSpaces));
+  return trimmedLines.join("\n");
+}
+
+exports.trimIdent = trimIdent;

package/dist/trimIdent-BAjmv_TG.mjs

@@ -0,0 +1,20 @@
+function trimIdent(text) {
+  const lines = text.split("\n");
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines.shift();
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  const minSpaces = lines.reduce((min, line) => {
+    if (line.trim() === "") {
+      return min;
+    }
+    const leadingSpaces = line.match(/^\s*/)[0].length;
+    return Math.min(min, leadingSpaces);
+  }, Infinity);
+  const trimmedLines = lines.map((line) => line.slice(minSpaces));
+  return trimmedLines.join("\n");
+}
+
+export { trimIdent as t };

package/dist/types-BoJh4Qfv.mjs

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+const UsageSchema = z.object({
+  input_tokens: z.number().int().nonnegative(),
+  cache_creation_input_tokens: z.number().int().nonnegative().optional(),
+  cache_read_input_tokens: z.number().int().nonnegative().optional(),
+  output_tokens: z.number().int().nonnegative(),
+  service_tier: z.string().nullish()
+}).passthrough();
+const RawJSONLinesSchema = z.discriminatedUnion("type", [
+  // User message - validates uuid and message.content
+  z.object({
+    type: z.literal("user"),
+    isSidechain: z.boolean().optional(),
+    isMeta: z.boolean().optional(),
+    uuid: z.string(),
+    // Used in getMessageKey()
+    message: z.object({
+      content: z.union([z.string(), z.any()])
+      // Used in sessionScanner.ts
+    }).passthrough()
+  }).passthrough(),
+  // Assistant message - only validates uuid and type
+  // message object is optional to handle synthetic error messages (isApiErrorMessage: true)
+  // which may have different structure than normal assistant messages
+  z.object({
+    uuid: z.string(),
+    type: z.literal("assistant"),
+    message: z.object({
+      usage: UsageSchema.optional(),
+      // Used in apiSession.ts
+      model: z.string().optional()
+      // Used for cost calculation
+    }).passthrough().optional()
+  }).passthrough(),
+  // Summary message - validates summary and leafUuid
+  z.object({
+    type: z.literal("summary"),
+    summary: z.string(),
+    // Used in apiSession.ts
+    leafUuid: z.string()
+    // Used in getMessageKey()
+  }).passthrough(),
+  // System message - validates uuid
+  z.object({
+    type: z.literal("system"),
+    uuid: z.string()
+    // Used in getMessageKey()
+  }).passthrough(),
+  // Progress message - hook progress events, not counted toward message limits
+  z.object({
+    type: z.literal("progress"),
+    uuid: z.string()
+  }).passthrough()
+]);
+
+export { RawJSONLinesSchema as R };

package/dist/types-DWeB7aqh.cjs

@@ -0,0 +1,59 @@
+'use strict';
+
+var z = require('zod');
+
+const UsageSchema = z.z.object({
+  input_tokens: z.z.number().int().nonnegative(),
+  cache_creation_input_tokens: z.z.number().int().nonnegative().optional(),
+  cache_read_input_tokens: z.z.number().int().nonnegative().optional(),
+  output_tokens: z.z.number().int().nonnegative(),
+  service_tier: z.z.string().nullish()
+}).passthrough();
+const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
+  // User message - validates uuid and message.content
+  z.z.object({
+    type: z.z.literal("user"),
+    isSidechain: z.z.boolean().optional(),
+    isMeta: z.z.boolean().optional(),
+    uuid: z.z.string(),
+    // Used in getMessageKey()
+    message: z.z.object({
+      content: z.z.union([z.z.string(), z.z.any()])
+      // Used in sessionScanner.ts
+    }).passthrough()
+  }).passthrough(),
+  // Assistant message - only validates uuid and type
+  // message object is optional to handle synthetic error messages (isApiErrorMessage: true)
+  // which may have different structure than normal assistant messages
+  z.z.object({
+    uuid: z.z.string(),
+    type: z.z.literal("assistant"),
+    message: z.z.object({
+      usage: UsageSchema.optional(),
+      // Used in apiSession.ts
+      model: z.z.string().optional()
+      // Used for cost calculation
+    }).passthrough().optional()
+  }).passthrough(),
+  // Summary message - validates summary and leafUuid
+  z.z.object({
+    type: z.z.literal("summary"),
+    summary: z.z.string(),
+    // Used in apiSession.ts
+    leafUuid: z.z.string()
+    // Used in getMessageKey()
+  }).passthrough(),
+  // System message - validates uuid
+  z.z.object({
+    type: z.z.literal("system"),
+    uuid: z.z.string()
+    // Used in getMessageKey()
+  }).passthrough(),
+  // Progress message - hook progress events, not counted toward message limits
+  z.z.object({
+    type: z.z.literal("progress"),
+    uuid: z.z.string()
+  }).passthrough()
+]);
+
+exports.RawJSONLinesSchema = RawJSONLinesSchema;

package/dist/uninstall-Buaz7d-X.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+var logger = require('./persistence-CBTtC_dm.cjs');
+var fs = require('fs');
+var child_process = require('child_process');
+var path = require('path');
+var os = require('os');
+var systemdScope = require('./systemdScope-DW3-UoKB.cjs');
+var controlClient = require('./controlClient-B23M-WPp.cjs');
+require('node:fs/promises');
+require('node:fs');
+require('node:os');
+require('node:path');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('chalk');
+require('./projectPath-ChLhdOyt.cjs');
+require('url');
+
+const PLIST_LABEL = "com.happy-cli.daemon";
+const PLIST_PATH = path.join(os.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+async function uninstall$2() {
+  if (!fs.existsSync(PLIST_PATH)) {
+    logger.logger.info("No LaunchAgent found. Auto-start is not enabled.");
+    return;
+  }
+  try {
+    child_process.execSync(`launchctl unload ${PLIST_PATH}`, { stdio: "ignore" });
+  } catch {
+  }
+  fs.unlinkSync(PLIST_PATH);
+  logger.logger.info("Daemon auto-start disabled.");
+}
+
+async function uninstall$1() {
+  const scopes = [systemdScope.systemdScopeFor(true), systemdScope.systemdScopeFor(false)].filter((scope) => fs.existsSync(scope.unitPath));
+  if (scopes.length === 0) {
+    logger.logger.info("No systemd service found. Auto-start is not enabled.");
+    return;
+  }
+  for (const scope of scopes) {
+    if (scope.system && !systemdScope.isRootUser()) {
+      logger.logger.info(`Skipping ${scope.unitPath} \u2014 removing it needs root: sudo happy daemon disable`);
+      continue;
+    }
+    try {
+      child_process.execSync(`systemctl ${scope.systemctlFlag} disable --now ${systemdScope.SERVICE_NAME}`.trim(), { stdio: "ignore" });
+    } catch {
+    }
+    fs.unlinkSync(scope.unitPath);
+    try {
+      child_process.execSync(`systemctl ${scope.systemctlFlag} daemon-reload`.trim(), { stdio: "ignore" });
+    } catch {
+    }
+    logger.logger.info(`Removed ${scope.unitPath}`);
+  }
+  logger.logger.info("Daemon auto-start disabled.");
+}
+
+async function uninstall() {
+  if (process.platform === "darwin") {
+    logger.logger.info("Removing daemon auto-start for macOS...");
+    await uninstall$2();
+  } else if (process.platform === "linux") {
+    logger.logger.info("Removing daemon auto-start for Linux...");
+    await uninstall$1();
+  } else {
+    throw new Error(`Unsupported platform: ${process.platform}. Only macOS and Linux are supported.`);
+  }
+  try {
+    await controlClient.stopDaemon();
+  } catch {
+  }
+}
+
+exports.uninstall = uninstall;

package/dist/uninstall-Dxf6_4mQ.mjs

@@ -0,0 +1,75 @@
+import { l as logger } from './persistence-DKfF81pd.mjs';
+import { existsSync, unlinkSync } from 'fs';
+import { execSync } from 'child_process';
+import { join } from 'path';
+import os from 'os';
+import { s as systemdScopeFor, i as isRootUser, S as SERVICE_NAME } from './systemdScope-BeOtAkhk.mjs';
+import { stopDaemon } from './controlClient-DB5tDU7V.mjs';
+import 'node:fs/promises';
+import 'node:fs';
+import 'node:os';
+import 'node:path';
+import 'zod';
+import 'node:crypto';
+import 'tweetnacl';
+import 'chalk';
+import './projectPath-BTBIMB57.mjs';
+import 'url';
+
+const PLIST_LABEL = "com.happy-cli.daemon";
+const PLIST_PATH = join(os.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+async function uninstall$2() {
+  if (!existsSync(PLIST_PATH)) {
+    logger.info("No LaunchAgent found. Auto-start is not enabled.");
+    return;
+  }
+  try {
+    execSync(`launchctl unload ${PLIST_PATH}`, { stdio: "ignore" });
+  } catch {
+  }
+  unlinkSync(PLIST_PATH);
+  logger.info("Daemon auto-start disabled.");
+}
+
+async function uninstall$1() {
+  const scopes = [systemdScopeFor(true), systemdScopeFor(false)].filter((scope) => existsSync(scope.unitPath));
+  if (scopes.length === 0) {
+    logger.info("No systemd service found. Auto-start is not enabled.");
+    return;
+  }
+  for (const scope of scopes) {
+    if (scope.system && !isRootUser()) {
+      logger.info(`Skipping ${scope.unitPath} \u2014 removing it needs root: sudo happy daemon disable`);
+      continue;
+    }
+    try {
+      execSync(`systemctl ${scope.systemctlFlag} disable --now ${SERVICE_NAME}`.trim(), { stdio: "ignore" });
+    } catch {
+    }
+    unlinkSync(scope.unitPath);
+    try {
+      execSync(`systemctl ${scope.systemctlFlag} daemon-reload`.trim(), { stdio: "ignore" });
+    } catch {
+    }
+    logger.info(`Removed ${scope.unitPath}`);
+  }
+  logger.info("Daemon auto-start disabled.");
+}
+
+async function uninstall() {
+  if (process.platform === "darwin") {
+    logger.info("Removing daemon auto-start for macOS...");
+    await uninstall$2();
+  } else if (process.platform === "linux") {
+    logger.info("Removing daemon auto-start for Linux...");
+    await uninstall$1();
+  } else {
+    throw new Error(`Unsupported platform: ${process.platform}. Only macOS and Linux are supported.`);
+  }
+  try {
+    await stopDaemon();
+  } catch {
+  }
+}
+
+export { uninstall };

package/dist/update-CGlIfa8e.cjs

@@ -0,0 +1,111 @@
+'use strict';
+
+var chalk = require('chalk');
+var node_child_process = require('node:child_process');
+var fs = require('node:fs');
+var logger = require('./persistence-CBTtC_dm.cjs');
+var controlClient = require('./controlClient-B23M-WPp.cjs');
+var spawnHappyCLI = require('./spawnHappyCLI-KiazE3kL.cjs');
+require('node:fs/promises');
+require('node:os');
+require('node:path');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('fs');
+require('./projectPath-ChLhdOyt.cjs');
+require('path');
+require('url');
+require('child_process');
+
+const PACKAGE_NAME = "@zonease/happy";
+function detectPackageManager() {
+  try {
+    const whichOutput = node_child_process.execSync("which happy", { encoding: "utf-8" }).trim();
+    const realPath = fs.realpathSync(whichOutput);
+    if (realPath.includes("/pnpm/") || realPath.includes("/pnpm-global/")) {
+      return "pnpm";
+    }
+    if (realPath.includes("/.yarn/") || realPath.includes("/yarn/")) {
+      return "yarn";
+    }
+  } catch {
+  }
+  return "npm";
+}
+function getUpgradeCommand(pm) {
+  switch (pm) {
+    case "pnpm":
+      return ["pnpm", "add", "-g", `${PACKAGE_NAME}@latest`];
+    case "yarn":
+      return ["yarn", "global", "add", `${PACKAGE_NAME}@latest`];
+    case "npm":
+      return ["npm", "install", "-g", `${PACKAGE_NAME}@latest`];
+  }
+}
+function getLatestVersion() {
+  try {
+    return node_child_process.execFileSync("npm", ["view", PACKAGE_NAME, "version"], { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+async function handleUpdateCommand() {
+  const currentVersion = logger.packageJson.version;
+  console.log(chalk.gray("Checking for updates..."));
+  const latestVersion = getLatestVersion();
+  if (!latestVersion) {
+    console.error(chalk.red("Failed to check latest version. Please check your network connection."));
+    process.exit(1);
+  }
+  console.log(`Current version: ${chalk.cyan(currentVersion)}`);
+  console.log(`Latest version:  ${chalk.cyan(latestVersion)}`);
+  console.log("");
+  if (currentVersion === latestVersion) {
+    console.log(chalk.green("\u2713 Already up to date"));
+    process.exit(0);
+  }
+  const pm = detectPackageManager();
+  const command = getUpgradeCommand(pm);
+  console.log(`Upgrading via ${chalk.bold(pm)}...`);
+  try {
+    node_child_process.execFileSync(command[0], command.slice(1), { stdio: "inherit" });
+  } catch {
+    console.error(chalk.red(`
+\u2717 Upgrade failed. You can try manually:`));
+    console.error(chalk.gray(`  ${command.join(" ")}`));
+    process.exit(1);
+  }
+  console.log(chalk.green(`
+\u2713 Upgraded to ${latestVersion}`));
+  try {
+    const daemonRunning = await controlClient.checkIfDaemonRunningAndCleanupStaleState();
+    if (daemonRunning) {
+      console.log("Restarting daemon...");
+      await controlClient.stopDaemon();
+      const child = spawnHappyCLI.spawnHappyCLI(["daemon", "start-sync"], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env
+      });
+      child.unref();
+      let started = false;
+      for (let i = 0; i < 50; i++) {
+        if (await controlClient.checkIfDaemonRunningAndCleanupStaleState()) {
+          started = true;
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      if (started) {
+        console.log(chalk.green("\u2713 Daemon restarted"));
+      } else {
+        console.log(chalk.yellow('\u26A0 Daemon restart timed out. Run "happy daemon start" manually.'));
+      }
+    }
+  } catch {
+  }
+  process.exit(0);
+}
+
+exports.handleUpdateCommand = handleUpdateCommand;