@adhdev/daemon-core 0.9.47 → 0.9.49

package/dist/index.mjs

@@ -1473,7 +1473,12 @@ function findBinary(name) {
   const isWin = os8.platform() === "win32";
   try {
     const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
-    return execSync3(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n")[0].trim();
+    return execSync3(cmd, {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"],
+      ...isWin ? { windowsHide: true } : {}
+    }).trim().split("\n")[0].trim();
   } catch {
     return isWin ? `${trimmed}.cmd` : trimmed;
   }
@@ -4154,6 +4159,83 @@ var init_provider_cli_adapter = __esm({
         if (!this.isWaitingForResponse) return "";
         return this.responseBuffer;
       }
+      getDebugSnapshot() {
+        const screenText = this.readTerminalScreenText();
+        const parsedResult = this.parsedStatusCache?.result && typeof this.parsedStatusCache.result === "object" ? this.parsedStatusCache.result : null;
+        return {
+          cliType: this.cliType,
+          cliName: this.cliName,
+          workingDir: this.workingDir,
+          currentStatus: this.currentStatus,
+          ready: this.ready,
+          isWaitingForResponse: this.isWaitingForResponse,
+          activeModal: this.activeModal,
+          parseErrorMessage: this.parseErrorMessage,
+          messageCounts: {
+            committed: this.committedMessages.length,
+            structured: this.structuredMessages.length,
+            visible: this.messages.length,
+            parsedCache: Array.isArray(parsedResult?.messages) ? parsedResult.messages.length : void 0
+          },
+          buffers: {
+            accumulatedLength: this.accumulatedBuffer.length,
+            accumulatedRawLength: this.accumulatedRawBuffer.length,
+            recentOutputLength: this.recentOutputBuffer.length,
+            responseLength: this.responseBuffer.length,
+            startupLength: this.startupBuffer.length,
+            accumulatedTail: this.accumulatedBuffer.slice(-24e3),
+            accumulatedRawTail: this.accumulatedRawBuffer.slice(-24e3),
+            recentOutputTail: this.recentOutputBuffer.slice(-12e3),
+            responseTail: this.responseBuffer.slice(-12e3)
+          },
+          terminal: {
+            screenText,
+            lastScreenSnapshot: this.lastScreenSnapshot,
+            lastScreenText: this.lastScreenText,
+            lastOutputAt: this.lastOutputAt,
+            lastNonEmptyOutputAt: this.lastNonEmptyOutputAt,
+            lastScreenChangeAt: this.lastScreenChangeAt,
+            lastScreenSnapshotReadAt: this.lastScreenSnapshotReadAt
+          },
+          parser: {
+            scriptNames: listCliScriptNames(this.cliScripts),
+            traceSessionId: this.traceSessionId,
+            traceSeq: this.traceSeq,
+            currentTurnScope: this.currentTurnScope,
+            parsedStatusCache: parsedResult ? {
+              id: parsedResult.id,
+              status: parsedResult.status,
+              title: parsedResult.title,
+              providerSessionId: parsedResult.providerSessionId,
+              transcriptAuthority: parsedResult.transcriptAuthority,
+              coverage: parsedResult.coverage,
+              messageCount: Array.isArray(parsedResult.messages) ? parsedResult.messages.length : void 0,
+              activeModal: parsedResult.activeModal
+            } : null,
+            pendingScriptStatus: this.pendingScriptStatus,
+            pendingScriptStatusSince: this.pendingScriptStatusSince
+          },
+          runtimeMetadata: this.getRuntimeMetadata(),
+          statusHistory: this.statusHistory.slice(-80),
+          traceEntries: this.traceEntries.slice(-120),
+          timing: {
+            spawnAt: this.spawnAt,
+            startupFirstOutputAt: this.startupFirstOutputAt,
+            submitPendingUntil: this.submitPendingUntil,
+            responseSettleIgnoreUntil: this.responseSettleIgnoreUntil,
+            responseEpoch: this.responseEpoch,
+            resizeSuppressUntil: this.resizeSuppressUntil,
+            lastApprovalResolvedAt: this.lastApprovalResolvedAt,
+            committedMessagesChangedAt: this.committedMessagesChangedAt
+          },
+          finish: {
+            idleFinishCandidate: this.idleFinishCandidate,
+            finishRetryCount: this.finishRetryCount,
+            submitRetryUsed: this.submitRetryUsed,
+            submitRetryPromptSnippet: this.submitRetryPromptSnippet
+          }
+        };
+      }
       getRuntimeMetadata() {
         if (!this.ptyProcess || typeof this.ptyProcess.getMetadata !== "function") return null;
         return this.ptyProcess.getMetadata();
@@ -5115,7 +5197,11 @@ function resolveCommandPath(command) {
 }
 function execAsync(cmd, timeoutMs = 5e3) {
   return new Promise((resolve12) => {
-    const child = exec(cmd, { encoding: "utf-8", timeout: timeoutMs }, (err, stdout) => {
+    const child = exec(cmd, {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      ...process.platform === "win32" ? { windowsHide: true } : {}
+    }, (err, stdout) => {
       if (err || !stdout?.trim()) {
         resolve12(null);
       } else {
@@ -10789,6 +10875,245 @@ function buildReadChatCommandResult(payload, args) {
     ...debugReadChat ? { debugReadChat } : {}
   };
 }
+var DEFAULT_DEBUG_SANITIZE_OPTIONS = {
+  maxDepth: 8,
+  maxArrayLength: 80,
+  maxObjectKeys: 120,
+  maxStringLength: 16e3
+};
+var SECRET_KEY_PATTERN = /(?:token|secret|password|passwd|authorization|cookie|api[_-]?key|access[_-]?key|refresh[_-]?token|client[_-]?secret|private[_-]?key)/i;
+function truncateDebugString(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength)}\u2026[truncated ${value.length - maxLength} chars]`;
+}
+function redactDebugSecrets(value) {
+  return value.replace(/(Authorization\s*:\s*Bearer\s+)[^\s'"`]+/gi, "$1[REDACTED:bearer]").replace(/(Bearer\s+)[A-Za-z0-9._~+\/-]{16,}=*/gi, "$1[REDACTED:bearer]").replace(/\b(?:gh[pousr]|github_pat)_[A-Za-z0-9_]{20,}\b/g, "[REDACTED:github-token]").replace(/\bsk-[A-Za-z0-9_-]{16,}\b/g, "[REDACTED:api-key]").replace(/\bxox[baprs]-[A-Za-z0-9-]{12,}\b/g, "[REDACTED:slack-token]").replace(/\b(?:adk|adm)_[A-Za-z0-9_-]{16,}\b/g, "[REDACTED:adhdev-token]").replace(/((?:api[_-]?key|token|secret|password|passwd|client[_-]?secret)\s*[:=]\s*)[^\s,'"`}&]+/gi, "$1[REDACTED:secret]").replace(/([?&](?:api[_-]?key|token|secret|password|client_secret)=)[^&#\s]+/gi, "$1[REDACTED:secret]");
+}
+function sanitizeDebugBundleValue(value, options = {}, depth = 0, keyHint = "") {
+  const normalizedOptions = { ...DEFAULT_DEBUG_SANITIZE_OPTIONS, ...options };
+  if (value === null || value === void 0) return value;
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "string") {
+    if (SECRET_KEY_PATTERN.test(keyHint) && value.trim()) return "[REDACTED:secret-field]";
+    return truncateDebugString(redactDebugSecrets(value), normalizedOptions.maxStringLength);
+  }
+  if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+  if (typeof value !== "object") return String(value);
+  if (depth >= normalizedOptions.maxDepth) return "[MaxDepth]";
+  if (Array.isArray(value)) {
+    const items = value.slice(0, normalizedOptions.maxArrayLength).map((item) => sanitizeDebugBundleValue(item, normalizedOptions, depth + 1, keyHint));
+    if (value.length > normalizedOptions.maxArrayLength) {
+      items.push(`[truncated ${value.length - normalizedOptions.maxArrayLength} items]`);
+    }
+    return items;
+  }
+  const record = value;
+  const result = {};
+  const entries = Object.entries(record).slice(0, normalizedOptions.maxObjectKeys);
+  for (const [key, item] of entries) {
+    result[key] = sanitizeDebugBundleValue(item, normalizedOptions, depth + 1, key);
+  }
+  const remaining = Object.keys(record).length - entries.length;
+  if (remaining > 0) result.__truncatedKeys = remaining;
+  return result;
+}
+function summarizeProviderForDebug(provider) {
+  if (!provider) return null;
+  const scripts = provider.scripts && typeof provider.scripts === "object" ? Object.keys(provider.scripts) : [];
+  const controls = Array.isArray(provider.controls) ? provider.controls.map((control) => ({
+    id: control?.id,
+    label: control?.label,
+    type: control?.type,
+    settingKey: control?.settingKey,
+    invokeScript: control?.invokeScript,
+    listScript: control?.listScript,
+    location: control?.location
+  })) : [];
+  return {
+    type: provider.type,
+    name: provider.name,
+    category: provider.category,
+    version: provider.version,
+    canonicalHistory: provider.canonicalHistory,
+    historyBehavior: provider.historyBehavior,
+    webviewMatchText: provider.webviewMatchText,
+    scriptNames: scripts,
+    controls,
+    resume: provider.resume
+  };
+}
+function summarizeSessionForDebug(session) {
+  if (!session || typeof session !== "object") return null;
+  return {
+    sessionId: session.sessionId,
+    instanceKey: session.instanceKey,
+    adapterKey: session.adapterKey,
+    providerType: session.providerType,
+    providerName: session.providerName,
+    transport: session.transport,
+    kind: session.kind,
+    cdpManagerKey: session.cdpManagerKey,
+    parentSessionId: session.parentSessionId,
+    providerSessionId: session.providerSessionId,
+    workspace: session.workspace,
+    title: session.title,
+    status: session.status,
+    mode: session.mode,
+    capabilities: session.capabilities
+  };
+}
+function summarizeStateForDebug(state) {
+  if (!state || typeof state !== "object") return null;
+  const activeChat = state.activeChat && typeof state.activeChat === "object" ? state.activeChat : null;
+  return {
+    type: state.type,
+    name: state.name,
+    category: state.category,
+    status: state.status,
+    instanceId: state.instanceId,
+    providerSessionId: state.providerSessionId,
+    title: state.title,
+    transport: state.transport,
+    mode: state.mode,
+    workspace: state.workspace,
+    runtime: state.runtime,
+    errorMessage: state.errorMessage,
+    errorReason: state.errorReason,
+    activeChat: activeChat ? {
+      status: activeChat.status,
+      title: activeChat.title,
+      messageCount: Array.isArray(activeChat.messages) ? activeChat.messages.length : void 0,
+      activeModal: activeChat.activeModal,
+      messagesTail: Array.isArray(activeChat.messages) ? activeChat.messages.slice(-10) : void 0
+    } : null,
+    controlValues: state.controlValues,
+    summaryMetadata: state.summaryMetadata
+  };
+}
+function buildDebugBundleText(bundle) {
+  return [
+    "# ADHDev Chat Debug Bundle",
+    "",
+    "```json",
+    JSON.stringify(bundle, null, 2),
+    "```"
+  ].join("\n");
+}
+async function handleGetChatDebugBundle(h, args) {
+  const provider = h.getProvider(args?.agentType);
+  const transport = getTargetTransport(h, provider);
+  const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
+  const providerType = provider?.type || getCurrentProviderType(h, args?.agentType || "");
+  const adapter = isCliLikeTransport(transport) ? getTargetedCliAdapter(h, args, provider?.type) : null;
+  const targetInstance = getTargetInstance(h, args);
+  let adapterStatus = null;
+  let parsedStatus = null;
+  let adapterDebugSnapshot = null;
+  let partialResponse = "";
+  if (adapter) {
+    try {
+      adapterStatus = adapter.getStatus?.();
+    } catch (error) {
+      adapterStatus = { error: error?.message || String(error) };
+    }
+    try {
+      parsedStatus = typeof adapter.getScriptParsedStatus === "function" ? parseMaybeJson(adapter.getScriptParsedStatus()) : null;
+    } catch (error) {
+      parsedStatus = { error: error?.message || String(error) };
+    }
+    try {
+      adapterDebugSnapshot = typeof adapter.getDebugSnapshot === "function" ? adapter.getDebugSnapshot() : null;
+    } catch (error) {
+      adapterDebugSnapshot = { error: error?.message || String(error) };
+    }
+    try {
+      partialResponse = adapter.getPartialResponse?.() || "";
+    } catch {
+      partialResponse = "";
+    }
+  }
+  let instanceState = null;
+  if (targetInstance?.getState) {
+    try {
+      instanceState = summarizeStateForDebug(targetInstance.getState());
+    } catch (error) {
+      instanceState = { error: error?.message || String(error) };
+    }
+  }
+  let readChat = null;
+  try {
+    const readResult = await handleReadChat(h, { ...args, tailLimit: Math.max(1, Math.min(40, Number(args?.tailLimit || 40))) });
+    readChat = readResult.success ? {
+      success: true,
+      status: readResult.status,
+      title: readResult.title,
+      totalMessages: readResult.totalMessages,
+      returnedMessages: Array.isArray(readResult.messages) ? readResult.messages.length : void 0,
+      syncMode: readResult.syncMode,
+      replaceFrom: readResult.replaceFrom,
+      lastMessageSignature: readResult.lastMessageSignature,
+      providerSessionId: readResult.providerSessionId,
+      transcriptAuthority: readResult.transcriptAuthority,
+      coverage: readResult.coverage,
+      activeModal: readResult.activeModal,
+      messagesTail: Array.isArray(readResult.messages) ? readResult.messages.slice(-20) : [],
+      debugReadChat: readResult.debugReadChat
+    } : { success: false, error: readResult.error };
+  } catch (error) {
+    readChat = { success: false, error: error?.message || String(error) };
+  }
+  const cdp = h.getCdp();
+  const rawBundle = {
+    version: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    target: {
+      targetSessionId,
+      providerType,
+      transport,
+      routeManagerKey: h.currentManagerKey,
+      currentIdeType: h.currentIdeType
+    },
+    session: summarizeSessionForDebug(h.currentSession),
+    provider: summarizeProviderForDebug(provider),
+    daemon: {
+      pid: process.pid,
+      platform: process.platform,
+      nodeVersion: process.version,
+      cwd: process.cwd()
+    },
+    cdp: {
+      requested: !!cdp,
+      connected: !!cdp?.isConnected,
+      managerKey: getCurrentManagerKey(h)
+    },
+    instanceState,
+    cli: adapter ? {
+      cliType: adapter.cliType,
+      cliName: adapter.cliName,
+      workingDir: adapter.workingDir,
+      status: adapterStatus?.status,
+      activeModal: adapterStatus?.activeModal,
+      messageCount: Array.isArray(adapterStatus?.messages) ? adapterStatus.messages.length : void 0,
+      messagesTail: Array.isArray(adapterStatus?.messages) ? adapterStatus.messages.slice(-20) : void 0,
+      parsedStatus,
+      partialResponse,
+      ready: typeof adapter.isReady === "function" ? adapter.isReady() : void 0,
+      processing: typeof adapter.isProcessing === "function" ? adapter.isProcessing() : void 0,
+      debugSnapshot: adapterDebugSnapshot
+    } : null,
+    readChat,
+    frontend: args?.frontendSnapshot && typeof args.frontendSnapshot === "object" ? args.frontendSnapshot : null,
+    recentLogs: getRecentLogs(80, "debug"),
+    recentDebugTrace: getRecentDebugTrace({ limit: 120 })
+  };
+  const bundle = sanitizeDebugBundleValue(rawBundle);
+  return {
+    success: true,
+    bundle,
+    text: buildDebugBundleText(bundle)
+  };
+}
 function didProviderConfirmSend(result) {
   const parsed = parseMaybeJson(result);
   if (parsed === true) return true;
@@ -12180,7 +12505,8 @@ function getCliScriptCommand(payload) {
   if (command.type !== "send_message" && command.type !== "pty_write") return null;
   const text = typeof command.text === "string" ? command.text.trim() : typeof command.message === "string" ? command.message.trim() : "";
   if (!text) return null;
-  return { type: command.type, text };
+  const enterCount = Number.isInteger(command.enterCount) && command.enterCount > 0 && command.enterCount <= 5 ? command.enterCount : void 0;
+  return { type: command.type, text, ...enterCount ? { enterCount } : {} };
 }
 
 // src/commands/stream-commands.ts
@@ -12438,7 +12764,12 @@ async function executeProviderScript(h, args, scriptName) {
       if (cliCommand?.type === "send_message" && cliCommand.text) {
         await adapter.sendMessage(cliCommand.text);
       } else if (cliCommand?.type === "pty_write" && cliCommand.text && adapter.writeRaw) {
+        const enterCount = cliCommand.enterCount || 1;
         await adapter.writeRaw(cliCommand.text + "\r");
+        for (let i = 1; i < enterCount; i += 1) {
+          await new Promise((resolve12) => setTimeout(resolve12, 50));
+          await adapter.writeRaw("\r");
+        }
       }
       applyProviderPatch(h, args, parsed.payload);
       return {
@@ -12979,6 +13310,8 @@ var DaemonCommandHandler = class {
       // ─── Chat commands (chat-commands.ts) ───────────────
       case "read_chat":
         return handleReadChat(this, args);
+      case "get_chat_debug_bundle":
+        return handleGetChatDebugBundle(this, args);
       case "chat_history":
         return handleChatHistory(this, args);
       case "send_chat":
@@ -13645,7 +13978,12 @@ var CliProviderInstance = class {
     if (cliCommand?.type === "send_message" && cliCommand.text) {
       await this.adapter.sendMessage(cliCommand.text);
     } else if (cliCommand?.type === "pty_write" && cliCommand.text) {
+      const enterCount = cliCommand.enterCount || 1;
       await this.adapter.writeRaw(cliCommand.text + "\r");
+      for (let i = 1; i < enterCount; i += 1) {
+        await new Promise((resolve12) => setTimeout(resolve12, 50));
+        await this.adapter.writeRaw("\r");
+      }
     }
     this.applyProviderResponse(parsed.payload, { phase: "immediate" });
   }
@@ -14659,7 +14997,8 @@ var AcpProviderInstance = class {
       cwd: this.workingDir,
       env,
       stdio: ["pipe", "pipe", "pipe"],
-      shell: spawnConfig.shell || false
+      shell: spawnConfig.shell || false,
+      ...process.platform === "win32" ? { windowsHide: true } : {}
     });
     const AUTH_ERROR_PATTERNS = [
       /unauthorized|unauthenticated/i,
@@ -15355,7 +15694,10 @@ function commandExists(command) {
     return existsSync10(expandExecutable(trimmed));
   }
   try {
-    execFileSync(process.platform === "win32" ? "where" : "which", [trimmed], { stdio: "ignore" });
+    execFileSync(process.platform === "win32" ? "where" : "which", [trimmed], {
+      stdio: "ignore",
+      ...process.platform === "win32" ? { windowsHide: true } : {}
+    });
     return true;
   } catch {
     return false;
@@ -18288,7 +18630,7 @@ async function launchMacOS(ide, port, workspace, newWindow) {
   const canUseAppLauncher = !!appName;
   const useAppLauncher = preferredMethod === "app" ? canUseAppLauncher : preferredMethod === "cli" ? false : !canUseCli && canUseAppLauncher;
   if (!useAppLauncher && ide.cliCommand) {
-    spawn2(ide.cliCommand, args, { detached: true, stdio: "ignore" }).unref();
+    spawn2(ide.cliCommand, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
   } else if (appName) {
     const openArgs = ["-a", appName, "--args", ...args];
     spawn2("open", openArgs, { detached: true, stdio: "ignore" }).unref();
@@ -18317,7 +18659,7 @@ async function launchLinux(ide, port, workspace, newWindow) {
   const args = ["--remote-debugging-port=" + port];
   if (newWindow) args.push("--new-window");
   if (workspace) args.push(workspace);
-  spawn2(cli, args, { detached: true, stdio: "ignore" }).unref();
+  spawn2(cli, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
 }
 function getAvailableIdeIds() {
   return getProviderLoader().getAvailableIdeTypes();
@@ -18801,16 +19143,28 @@ function appendUpgradeLog(message) {
   } catch {
   }
 }
-function resolveSiblingNpmExecutable(nodeExecutable) {
+function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platform) {
   const binDir = path16.dirname(nodeExecutable);
-  const candidates = process.platform === "win32" ? ["npm.cmd", "npm.exe", "npm"] : ["npm"];
-  for (const candidate of candidates) {
+  if (platform10 === "win32") {
+    const npmCliPath = path16.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
+    if (fs8.existsSync(npmCliPath)) {
+      return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform10) };
+    }
+    for (const candidate of ["npm.exe", "npm"]) {
+      const candidatePath = path16.join(binDir, candidate);
+      if (fs8.existsSync(candidatePath)) {
+        return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
+      }
+    }
+    return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform10) };
+  }
+  for (const candidate of ["npm"]) {
     const candidatePath = path16.join(binDir, candidate);
     if (fs8.existsSync(candidatePath)) {
-      return candidatePath;
+      return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
     }
   }
-  return "npm";
+  return { executable: "npm", argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
 }
 function findCurrentPackageRoot(currentCliPath, packageName) {
   if (!currentCliPath) return null;
@@ -18859,31 +19213,50 @@ function resolveInstallPrefixFromPackageRoot(packageRoot, packageName) {
 }
 function resolveCurrentGlobalInstallSurface(options) {
   const packageRoot = findCurrentPackageRoot(options.currentCliPath || process.argv[1], options.packageName);
+  const npmInvocation = resolveSiblingNpmInvocation(options.nodeExecutable || process.execPath, options.platform);
   return {
-    npmExecutable: resolveSiblingNpmExecutable(options.nodeExecutable || process.execPath),
+    npmExecutable: npmInvocation.executable,
+    npmArgsPrefix: npmInvocation.argsPrefix,
     packageRoot,
-    installPrefix: packageRoot ? resolveInstallPrefixFromPackageRoot(packageRoot, options.packageName) : null
+    installPrefix: packageRoot ? resolveInstallPrefixFromPackageRoot(packageRoot, options.packageName) : null,
+    execOptions: npmInvocation.execOptions
   };
 }
 function buildPinnedGlobalInstallCommand(options) {
   const surface = resolveCurrentGlobalInstallSurface(options);
-  const args = ["install", "-g", `${options.packageName}@${options.targetVersion || "latest"}`, "--force"];
+  const args = [...surface.npmArgsPrefix || [], "install", "-g", `${options.packageName}@${options.targetVersion || "latest"}`, "--force"];
   if (surface.installPrefix) {
     args.push("--prefix", surface.installPrefix);
   }
   return {
     command: surface.npmExecutable,
     args,
-    surface
+    surface,
+    execOptions: surface.execOptions || getNpmExecOptions(options.platform)
   };
 }
-function getNpmExecOptions() {
-  return { shell: process.platform === "win32" };
+function getNpmExecOptions(platform10 = process.platform) {
+  if (platform10 === "win32") {
+    return { shell: false, windowsHide: true };
+  }
+  return { shell: false };
+}
+function execNpmCommandSync(args, options = {}, surface) {
+  const execOptions = surface?.execOptions || getNpmExecOptions();
+  return execFileSync2(
+    surface?.npmExecutable || "npm",
+    [...surface?.npmArgsPrefix || [], ...args],
+    {
+      ...options,
+      ...execOptions,
+      ...process.platform === "win32" ? { windowsHide: true } : {}
+    }
+  );
 }
 function killPid(pid) {
   try {
     if (process.platform === "win32") {
-      execFileSync2("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+      execFileSync2("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     } else {
       process.kill(pid, "SIGTERM");
     }
@@ -18902,7 +19275,7 @@ function getWindowsProcessCommandLine(pid) {
       "Bypass",
       "-Command",
       `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`
-    ], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    ], { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
     if (psOut) return psOut;
   } catch {
   }
@@ -18913,7 +19286,7 @@ function getWindowsProcessCommandLine(pid) {
       pidFilter,
       "get",
       "CommandLine"
-    ], { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"] }).trim();
+    ], { encoding: "utf8", timeout: 3e3, stdio: ["ignore", "pipe", "ignore"], windowsHide: true }).trim();
     if (wmicOut) return wmicOut;
   } catch {
   }
@@ -18973,11 +19346,10 @@ function removeDaemonPidFile() {
   }
 }
 function cleanupStaleGlobalInstallDirs(pkgName, surface) {
-  const npmExecOpts = getNpmExecOptions();
   const prefixArgs = surface.installPrefix ? ["--prefix", surface.installPrefix] : [];
-  const npmRoot = execFileSync2(surface.npmExecutable, ["root", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
+  const npmRoot = String(execNpmCommandSync(["root", "-g", ...prefixArgs], { encoding: "utf8" }, surface)).trim();
   if (!npmRoot) return;
-  const npmPrefix = surface.installPrefix || execFileSync2(surface.npmExecutable, ["prefix", "-g", ...prefixArgs], { encoding: "utf8", ...npmExecOpts }).trim();
+  const npmPrefix = surface.installPrefix || String(execNpmCommandSync(["prefix", "-g", ...prefixArgs], { encoding: "utf8" }, surface)).trim();
   const binDir = process.platform === "win32" ? npmPrefix : path16.join(npmPrefix, "bin");
   const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
   const binNames = /* @__PURE__ */ new Set([packageBaseName]);
@@ -19047,7 +19419,7 @@ async function runDaemonUpgradeHelper(payload) {
       encoding: "utf8",
       stdio: "pipe",
       maxBuffer: 20 * 1024 * 1024,
-      ...getNpmExecOptions()
+      ...installCommand.execOptions
     }
   );
   if (installOutput.trim()) {
@@ -19762,18 +20134,18 @@ var DaemonCommandRouter = class {
       case "daemon_upgrade": {
         LOG.info("Upgrade", "Remote upgrade requested from dashboard");
         try {
-          const { execSync: execSync7 } = await import("child_process");
           const isStandalone = this.deps.packageName === "@adhdev/daemon-standalone" || process.argv[1]?.includes("daemon-standalone");
           const pkgName = isStandalone ? "@adhdev/daemon-standalone" : "adhdev";
-          const latest = execSync7(`npm view ${pkgName} version`, { encoding: "utf-8", timeout: 1e4 }).trim();
+          const npmSurface = resolveCurrentGlobalInstallSurface({ packageName: pkgName });
+          const latest = String(execNpmCommandSync(["view", pkgName, "version"], { encoding: "utf-8", timeout: 1e4 }, npmSurface)).trim();
           LOG.info("Upgrade", `Latest ${pkgName}: v${latest}`);
           let currentInstalled = null;
           try {
-            const currentJson = execSync7(`npm ls -g ${pkgName} --depth=0 --json`, {
+            const currentJson = String(execNpmCommandSync(["ls", "-g", pkgName, "--depth=0", "--json"], {
               encoding: "utf-8",
               timeout: 1e4,
               stdio: ["pipe", "pipe", "pipe"]
-            }).trim();
+            }, npmSurface)).trim();
             const parsed = JSON.parse(currentJson);
             currentInstalled = parsed?.dependencies?.[pkgName]?.version || null;
           } catch {
@@ -27857,6 +28229,7 @@ export {
   detectCLIs,
   detectIDEs,
   ensureSessionHostReady,
+  execNpmCommandSync,
   findCdpManager,
   flattenMessageParts,
   forwardAgentStreamsToIdeInstance,
@@ -27867,6 +28240,7 @@ export {
   getDebugRuntimeConfig,
   getHostMemorySnapshot,
   getLogLevel,
+  getNpmExecOptions,
   getRecentActivity,
   getRecentCommands,
   getRecentDebugTrace,