@zonease/happy 0.6.37 → 0.6.39

package/dist/systemdScope-DW3-UoKB.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var path = require('node:path');
+var os = require('node:os');
+
+const SERVICE_NAME = "happy-daemon.service";
+function systemdScopeFor(isRoot) {
+  if (isRoot) {
+    return {
+      system: true,
+      unitPath: path.join("/etc/systemd/system", SERVICE_NAME),
+      systemctlFlag: "",
+      wantedBy: "multi-user.target"
+    };
+  }
+  return {
+    system: false,
+    unitPath: path.join(os.homedir(), ".config", "systemd", "user", SERVICE_NAME),
+    systemctlFlag: "--user",
+    wantedBy: "default.target"
+  };
+}
+function isRootUser() {
+  return typeof process.getuid === "function" && process.getuid() === 0;
+}
+
+exports.SERVICE_NAME = SERVICE_NAME;
+exports.isRootUser = isRootUser;
+exports.systemdScopeFor = systemdScopeFor;

package/dist/task-CQzrHRZe.mjs

@@ -0,0 +1,165 @@
+import chalk from 'chalk';
+import { resolve } from 'node:path';
+import { r as readCredentials } from './persistence-BFjvtUad.mjs';
+import { r as runSessionList } from './sessionList-BCSw3qYt.mjs';
+import { r as runSessionSummary } from './sessionSummary-lHGBWQSb.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-BE8dD20T.mjs';
+import 'qrcode-terminal';
+import './time-DgsBLJA_.mjs';
+import './browser-Dll5hxOV.mjs';
+import 'open';
+import 'react';
+import 'ink';
+import './sessionKeyCache-D2BwO91C.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/task-CSpaC9HX.cjs

@@ -0,0 +1,167 @@
+'use strict';
+
+var chalk = require('chalk');
+var path = require('node:path');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var sessionList = require('./sessionList-ICJsjNtJ.cjs');
+var sessionSummary = require('./sessionSummary-Bkz52BPh.cjs');
+var workflowCommon = require('./workflowCommon-Bl568-rt.cjs');
+require('node:fs/promises');
+require('node:fs');
+require('node:os');
+require('zod');
+require('node:crypto');
+require('tweetnacl');
+require('fs');
+require('axios');
+require('./auth-BIleVCw0.cjs');
+require('qrcode-terminal');
+require('./time-Bj2HRkKH.cjs');
+require('./browser-Cc08m7of.cjs');
+require('open');
+require('react');
+require('ink');
+require('./sessionKeyCache-4Tp8pJ3N.cjs');
+
+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 = path.resolve(projectPath);
+  return sessions.find((session) => {
+    if (!session.path) return false;
+    const path$1 = path.resolve(session.path);
+    return path$1 === resolved || path$1.startsWith(`${resolved}/`) || resolved.startsWith(`${path$1}/`);
+  });
+}
+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 = workflowCommon.parseWorkflowArgs(args.slice(1), /* @__PURE__ */ new Set(["--session", "--project", "--limit", "--max-turns", "--text-limit", "--out"]));
+  const credentials = await logger.readCredentials();
+  if (!credentials) {
+    throw new Error('No happy credentials found. Run "happy auth login" first.');
+  }
+  let sessionId = workflowCommon.stringFlag(parsed, "--session") ?? parsed.positionals[0];
+  let source = "session";
+  if (!sessionId && workflowCommon.booleanFlag(parsed, "--recent")) {
+    const result = await sessionList.runSessionList(credentials, { status: "all", limit: 150 });
+    const recent = findRecentSession(result.sessions, workflowCommon.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: workflowCommon.numberFlag(parsed, "--limit"),
+    maxTurns: workflowCommon.numberFlag(parsed, "--max-turns"),
+    textLimit: workflowCommon.numberFlag(parsed, "--text-limit"),
+    includeTools: true
+  };
+  const summary = await sessionSummary.runSessionSummary(credentials, input);
+  const brief = buildBriefMarkdown(summary, source);
+  if (workflowCommon.booleanFlag(parsed, "--json")) {
+    console.log(JSON.stringify({ source, summary, brief }, null, 2));
+    return;
+  }
+  await workflowCommon.printOrWriteOutput(brief, workflowCommon.stringFlag(parsed, "--out"));
+}
+
+exports.handleTaskCommand = 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-BiKyRAb1.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+var logger = require('./persistence-JLUn_Nou.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-DZMIsKsT.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;