adhdev 0.9.47 → 0.9.49

package/dist/cli/index.js

@@ -1495,7 +1495,11 @@ function resolveCommandPath(command) {
 }
 function execAsync(cmd, timeoutMs = 5e3) {
   return new Promise((resolve18) => {
-    const child = (0, import_child_process2.exec)(cmd, { encoding: "utf-8", timeout: timeoutMs }, (err, stdout) => {
+    const child = (0, import_child_process2.exec)(cmd, {
+      encoding: "utf-8",
+      timeout: timeoutMs,
+      ...process.platform === "win32" ? { windowsHide: true } : {}
+    }, (err, stdout) => {
       if (err || !stdout?.trim()) {
         resolve18(null);
       } else {
@@ -8106,6 +8110,238 @@ function buildReadChatCommandResult(payload, args) {
     ...debugReadChat ? { debugReadChat } : {}
   };
 }
+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 record2 = value;
+  const result = {};
+  const entries = Object.entries(record2).slice(0, normalizedOptions.maxObjectKeys);
+  for (const [key, item] of entries) {
+    result[key] = sanitizeDebugBundleValue(item, normalizedOptions, depth + 1, key);
+  }
+  const remaining = Object.keys(record2).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 (error48) {
+      adapterStatus = { error: error48?.message || String(error48) };
+    }
+    try {
+      parsedStatus = typeof adapter.getScriptParsedStatus === "function" ? parseMaybeJson(adapter.getScriptParsedStatus()) : null;
+    } catch (error48) {
+      parsedStatus = { error: error48?.message || String(error48) };
+    }
+    try {
+      adapterDebugSnapshot = typeof adapter.getDebugSnapshot === "function" ? adapter.getDebugSnapshot() : null;
+    } catch (error48) {
+      adapterDebugSnapshot = { error: error48?.message || String(error48) };
+    }
+    try {
+      partialResponse = adapter.getPartialResponse?.() || "";
+    } catch {
+      partialResponse = "";
+    }
+  }
+  let instanceState = null;
+  if (targetInstance?.getState) {
+    try {
+      instanceState = summarizeStateForDebug(targetInstance.getState());
+    } catch (error48) {
+      instanceState = { error: error48?.message || String(error48) };
+    }
+  }
+  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 (error48) {
+    readChat = { success: false, error: error48?.message || String(error48) };
+  }
+  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;
@@ -9079,7 +9315,7 @@ async function handleResolveAction(h, args) {
   }
   return { success: false, error: "resolveAction script not available for this provider" };
 }
-var RECENT_SEND_WINDOW_MS, READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS, recentSendByTarget;
+var RECENT_SEND_WINDOW_MS, READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS, recentSendByTarget, DEFAULT_DEBUG_SANITIZE_OPTIONS, SECRET_KEY_PATTERN;
 var init_chat_commands = __esm({
   "../../oss/packages/daemon-core/src/commands/chat-commands.ts"() {
     "use strict";
@@ -9094,6 +9330,13 @@ var init_chat_commands = __esm({
     RECENT_SEND_WINDOW_MS = 1200;
     READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25e3;
     recentSendByTarget = /* @__PURE__ */ new Map();
+    DEFAULT_DEBUG_SANITIZE_OPTIONS = {
+      maxDepth: 8,
+      maxArrayLength: 80,
+      maxObjectKeys: 120,
+      maxStringLength: 16e3
+    };
+    SECRET_KEY_PATTERN = /(?:token|secret|password|passwd|authorization|cookie|api[_-]?key|access[_-]?key|refresh[_-]?token|client[_-]?secret|private[_-]?key)/i;
   }
 });
 
@@ -9522,7 +9765,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 } : {} };
 }
 var init_cli_script_results = __esm({
   "../../oss/packages/daemon-core/src/providers/cli-script-results.ts"() {
@@ -9784,7 +10028,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((resolve18) => setTimeout(resolve18, 50));
+          await adapter.writeRaw("\r");
+        }
       }
       applyProviderPatch(h, args, parsed.payload);
       return {
@@ -10355,6 +10604,8 @@ var init_handler = __esm({
           // ─── 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":
@@ -12144,7 +12395,12 @@ function findBinary(name) {
   const isWin = os11.platform() === "win32";
   try {
     const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
-    return (0, import_child_process4.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n")[0].trim();
+    return (0, import_child_process4.execSync)(cmd, {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"],
+      ...isWin ? { windowsHide: true } : {}
+    }).trim().split("\n")[0].trim();
   } catch {
     return isWin ? `${trimmed}.cmd` : trimmed;
   }
@@ -14829,6 +15085,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();
@@ -15581,7 +15914,12 @@ var init_cli_provider_instance = __esm({
         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((resolve18) => setTimeout(resolve18, 50));
+            await this.adapter.writeRaw("\r");
+          }
         }
         this.applyProviderResponse(parsed.payload, { phase: "immediate" });
       }
@@ -32900,7 +33238,8 @@ var init_acp_provider_instance = __esm({
           cwd: this.workingDir,
           env: env3,
           stdio: ["pipe", "pipe", "pipe"],
-          shell: spawnConfig.shell || false
+          shell: spawnConfig.shell || false,
+          ...process.platform === "win32" ? { windowsHide: true } : {}
         });
         const AUTH_ERROR_PATTERNS = [
           /unauthorized|unauthenticated/i,
@@ -33599,7 +33938,10 @@ function commandExists(command) {
     return (0, import_fs5.existsSync)(expandExecutable(trimmed));
   }
   try {
-    (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], { stdio: "ignore" });
+    (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
+      stdio: "ignore",
+      ...process.platform === "win32" ? { windowsHide: true } : {}
+    });
     return true;
   } catch {
     return false;
@@ -38318,7 +38660,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) {
-    (0, import_child_process7.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore" }).unref();
+    (0, import_child_process7.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
   } else if (appName) {
     const openArgs = ["-a", appName, "--args", ...args];
     (0, import_child_process7.spawn)("open", openArgs, { detached: true, stdio: "ignore" }).unref();
@@ -38347,7 +38689,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);
-  (0, import_child_process7.spawn)(cli, args, { detached: true, stdio: "ignore" }).unref();
+  (0, import_child_process7.spawn)(cli, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
 }
 function getAvailableIdeIds() {
   return getProviderLoader().getAvailableIdeTypes();
@@ -38851,16 +39193,28 @@ function appendUpgradeLog(message) {
   } catch {
   }
 }
-function resolveSiblingNpmExecutable(nodeExecutable) {
+function resolveSiblingNpmInvocation(nodeExecutable, platform12 = process.platform) {
   const binDir = path17.dirname(nodeExecutable);
-  const candidates = process.platform === "win32" ? ["npm.cmd", "npm.exe", "npm"] : ["npm"];
-  for (const candidate of candidates) {
+  if (platform12 === "win32") {
+    const npmCliPath = path17.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
+    if (fs8.existsSync(npmCliPath)) {
+      return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform12) };
+    }
+    for (const candidate of ["npm.exe", "npm"]) {
+      const candidatePath = path17.join(binDir, candidate);
+      if (fs8.existsSync(candidatePath)) {
+        return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform12) };
+      }
+    }
+    return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform12) };
+  }
+  for (const candidate of ["npm"]) {
     const candidatePath = path17.join(binDir, candidate);
     if (fs8.existsSync(candidatePath)) {
-      return candidatePath;
+      return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform12) };
     }
   }
-  return "npm";
+  return { executable: "npm", argsPrefix: [], execOptions: getNpmExecOptions(platform12) };
 }
 function findCurrentPackageRoot(currentCliPath, packageName) {
   if (!currentCliPath) return null;
@@ -38909,31 +39263,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(platform12 = process.platform) {
+  if (platform12 === "win32") {
+    return { shell: false, windowsHide: true };
+  }
+  return { shell: false };
+}
+function execNpmCommandSync(args, options = {}, surface) {
+  const execOptions = surface?.execOptions || getNpmExecOptions();
+  return (0, import_child_process8.execFileSync)(
+    surface?.npmExecutable || "npm",
+    [...surface?.npmArgsPrefix || [], ...args],
+    {
+      ...options,
+      ...execOptions,
+      ...process.platform === "win32" ? { windowsHide: true } : {}
+    }
+  );
 }
 function killPid(pid) {
   try {
     if (process.platform === "win32") {
-      (0, import_child_process8.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore" });
+      (0, import_child_process8.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     } else {
       process.kill(pid, "SIGTERM");
     }
@@ -38952,7 +39325,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 {
   }
@@ -38963,7 +39336,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 {
   }
@@ -39023,11 +39396,10 @@ function removeDaemonPidFile() {
   }
 }
 function cleanupStaleGlobalInstallDirs(pkgName, surface) {
-  const npmExecOpts = getNpmExecOptions();
   const prefixArgs = surface.installPrefix ? ["--prefix", surface.installPrefix] : [];
-  const npmRoot = (0, import_child_process8.execFileSync)(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 || (0, import_child_process8.execFileSync)(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 : path17.join(npmPrefix, "bin");
   const packageBaseName = pkgName.startsWith("@") ? pkgName.split("/")[1] : pkgName;
   const binNames = /* @__PURE__ */ new Set([packageBaseName]);
@@ -39097,7 +39469,7 @@ async function runDaemonUpgradeHelper(payload) {
       encoding: "utf8",
       stdio: "pipe",
       maxBuffer: 20 * 1024 * 1024,
-      ...getNpmExecOptions()
+      ...installCommand.execOptions
     }
   );
   if (installOutput.trim()) {
@@ -39849,18 +40221,18 @@ var init_router = __esm({
           case "daemon_upgrade": {
             LOG.info("Upgrade", "Remote upgrade requested from dashboard");
             try {
-              const { execSync: execSync8 } = 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 = execSync8(`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 = execSync8(`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 {
@@ -48109,6 +48481,7 @@ __export(src_exports, {
   detectCLIs: () => detectCLIs,
   detectIDEs: () => detectIDEs,
   ensureSessionHostReady: () => ensureSessionHostReady,
+  execNpmCommandSync: () => execNpmCommandSync,
   findCdpManager: () => findCdpManager,
   flattenMessageParts: () => flattenMessageParts,
   forwardAgentStreamsToIdeInstance: () => forwardAgentStreamsToIdeInstance,
@@ -48119,6 +48492,7 @@ __export(src_exports, {
   getDebugRuntimeConfig: () => getDebugRuntimeConfig,
   getHostMemorySnapshot: () => getHostMemorySnapshot,
   getLogLevel: () => getLogLevel,
+  getNpmExecOptions: () => getNpmExecOptions,
   getRecentActivity: () => getRecentActivity,
   getRecentCommands: () => getRecentCommands,
   getRecentDebugTrace: () => getRecentDebugTrace,
@@ -87844,12 +88218,15 @@ function verifyPublishedMandatoryUpdateTarget(packageName, targetVersion, deps =
   const validation = validateMandatoryUpdateTarget(targetVersion);
   if (!validation.valid) throw new Error(validation.error || "invalid mandatory update target");
   const run = deps.execFileSync || import_child_process14.execFileSync;
-  const npmExecutable = deps.npmExecutable || resolveCurrentGlobalInstallSurface({ packageName }).npmExecutable;
-  const published = String(run(npmExecutable, ["view", `${packageName}@${targetVersion}`, "version"], {
+  const surface = resolveCurrentGlobalInstallSurface({ packageName });
+  const npmExecutable = deps.npmExecutable || surface.npmExecutable;
+  const npmArgsPrefix = deps.npmArgsPrefix || surface.npmArgsPrefix || [];
+  const execOptions = deps.execOptions || surface.execOptions || {};
+  const published = String(run(npmExecutable, [...npmArgsPrefix, "view", `${packageName}@${targetVersion}`, "version"], {
     encoding: "utf-8",
     timeout: 1e4,
     stdio: ["pipe", "pipe", "pipe"],
-    ...process.platform === "win32" ? { shell: true, windowsHide: true } : {}
+    ...execOptions
   })).trim();
   if (published !== targetVersion) {
     throw new Error(`Published version mismatch: expected ${targetVersion}, got ${published || "unknown"}`);
@@ -88056,7 +88433,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.47" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.49" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -89191,10 +89568,11 @@ function hasCloudMachineAuth() {
 function readLatestPublishedCliVersion(execFileSyncLocal) {
   const surface = resolveCurrentGlobalInstallSurface({ packageName: "adhdev" });
   try {
-    return execFileSyncLocal(surface.npmExecutable, ["view", "adhdev", "version"], {
+    return execFileSyncLocal(surface.npmExecutable, [...surface.npmArgsPrefix || [], "view", "adhdev", "version"], {
       encoding: "utf-8",
       timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      ...surface.execOptions
     }).trim();
   } catch {
     return null;
@@ -89202,7 +89580,7 @@ function readLatestPublishedCliVersion(execFileSyncLocal) {
 }
 function readInstalledGlobalCliVersion(execFileSyncLocal) {
   const surface = resolveCurrentGlobalInstallSurface({ packageName: "adhdev" });
-  const args = ["list", "-g", "adhdev", "--json"];
+  const args = [...surface.npmArgsPrefix || [], "list", "-g", "adhdev", "--json"];
   if (surface.installPrefix) {
     args.push("--prefix", surface.installPrefix);
   }
@@ -89210,7 +89588,8 @@ function readInstalledGlobalCliVersion(execFileSyncLocal) {
     const result = execFileSyncLocal(surface.npmExecutable, args, {
       encoding: "utf-8",
       timeout: 5e3,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      ...surface.execOptions
     });
     const parsed = JSON.parse(result);
     return parsed.dependencies?.adhdev?.version || null;
@@ -89255,7 +89634,8 @@ async function checkForUpdate() {
       execFileSync6(installCommand.command, installCommand.args, {
         encoding: "utf-8",
         timeout: 6e4,
-        stdio: ["pipe", "pipe", "pipe"]
+        stdio: ["pipe", "pipe", "pipe"],
+        ...installCommand.execOptions
       });
       spinner.succeed(`Updated to v${latestVersion}`);
       console.log();
@@ -89541,7 +89921,8 @@ async function installCliOnly() {
     execFileSyncLocal(installCommand.command, installCommand.args, {
       encoding: "utf-8",
       timeout: 6e4,
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      ...installCommand.execOptions
     });
     const newVersion = readInstalledGlobalCliVersion(execFileSyncLocal) || "latest";
     installSpinner.succeed(`adhdev CLI ${currentVersion ? "updated" : "installed"} \u2713 (v${newVersion})`);
@@ -91932,7 +92313,9 @@ async function runDaemonUpgrade(options, pkgVersion3) {
     console.log(source_default.cyan("\n  Checking for updates..."));
     let latest;
     try {
-      latest = execSync8("npm view adhdev version", { encoding: "utf-8" }).trim();
+      const { execNpmCommandSync: execNpmCommandSync2, resolveCurrentGlobalInstallSurface: resolveCurrentGlobalInstallSurface2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+      const npmSurface = resolveCurrentGlobalInstallSurface2({ packageName: "adhdev" });
+      latest = String(execNpmCommandSync2(["view", "adhdev", "version"], { encoding: "utf-8" }, npmSurface)).trim();
     } catch (e) {
       console.log(source_default.red(`
   \u2717 Failed to check latest version: ${e?.message}