@adhdev/daemon-core 0.9.47 → 0.9.49

package/src/commands/upgrade-helper.ts

@@ -1,4 +1,4 @@
-import { execFileSync } from 'child_process';
+import { execFileSync, type ExecFileSyncOptions } from 'child_process';
 import { spawn } from 'child_process';
 import * as fs from 'fs';
 import * as os from 'os';
@@ -17,16 +17,21 @@ export interface DaemonUpgradeHelperPayload {
 
 export interface CurrentGlobalInstallSurface {
   npmExecutable: string;
+  npmArgsPrefix?: string[];
   packageRoot: string | null;
   installPrefix: string | null;
+  execOptions?: NpmExecOptions;
 }
 
 export interface PinnedGlobalInstallCommand {
   command: string;
   args: string[];
   surface: CurrentGlobalInstallSurface;
+  execOptions: NpmExecOptions;
 }
 
+export type NpmExecOptions = { shell: boolean; windowsHide?: boolean };
+
 function getUpgradeLogPath(): string {
   const home = os.homedir();
   const dir = path.join(home, '.adhdev');
@@ -43,18 +48,32 @@ function appendUpgradeLog(message: string): void {
   }
 }
 
-function resolveSiblingNpmExecutable(nodeExecutable: string): string {
+function resolveSiblingNpmInvocation(nodeExecutable: string, platform: NodeJS.Platform = process.platform): {
+  executable: string;
+  argsPrefix: string[];
+  execOptions: NpmExecOptions;
+} {
   const binDir = path.dirname(nodeExecutable);
-  const candidates = process.platform === 'win32'
-    ? ['npm.cmd', 'npm.exe', 'npm']
-    : ['npm'];
-  for (const candidate of candidates) {
+  if (platform === 'win32') {
+    const npmCliPath = path.join(binDir, 'node_modules', 'npm', 'bin', 'npm-cli.js');
+    if (fs.existsSync(npmCliPath)) {
+      return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform) };
+    }
+    for (const candidate of ['npm.exe', 'npm']) {
+      const candidatePath = path.join(binDir, candidate);
+      if (fs.existsSync(candidatePath)) {
+        return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform) };
+      }
+    }
+    return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform) };
+  }
+  for (const candidate of ['npm']) {
     const candidatePath = path.join(binDir, candidate);
     if (fs.existsSync(candidatePath)) {
-      return candidatePath;
+      return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform) };
     }
   }
-  return 'npm';
+  return { executable: 'npm', argsPrefix: [], execOptions: getNpmExecOptions(platform) };
 }
 
 function findCurrentPackageRoot(currentCliPath: string | undefined, packageName: string): string | null {
@@ -117,12 +136,16 @@ export function resolveCurrentGlobalInstallSurface(options: {
   packageName: string;
   currentCliPath?: string;
   nodeExecutable?: string;
+  platform?: NodeJS.Platform;
 }): CurrentGlobalInstallSurface {
   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,
+    execOptions: npmInvocation.execOptions,
   };
 }
 
@@ -131,9 +154,10 @@ export function buildPinnedGlobalInstallCommand(options: {
   targetVersion: string;
   currentCliPath?: string;
   nodeExecutable?: string;
+  platform?: NodeJS.Platform;
 }): PinnedGlobalInstallCommand {
   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);
   }
@@ -141,17 +165,38 @@ export function buildPinnedGlobalInstallCommand(options: {
     command: surface.npmExecutable,
     args,
     surface,
+    execOptions: surface.execOptions || getNpmExecOptions(options.platform),
   };
 }
 
-function getNpmExecOptions(): { shell: boolean } {
-  return { shell: process.platform === 'win32' };
+export function getNpmExecOptions(platform: NodeJS.Platform = process.platform): NpmExecOptions {
+  if (platform === 'win32') {
+    return { shell: false, windowsHide: true };
+  }
+  return { shell: false };
+}
+
+export function execNpmCommandSync(
+  args: string[],
+  options: ExecFileSyncOptions = {},
+  surface?: Pick<CurrentGlobalInstallSurface, 'npmExecutable' | 'npmArgsPrefix' | 'execOptions'>,
+): Buffer | string {
+  const execOptions = surface?.execOptions || getNpmExecOptions();
+  return execFileSync(
+    surface?.npmExecutable || 'npm',
+    [...(surface?.npmArgsPrefix || []), ...args],
+    {
+      ...options,
+      ...execOptions,
+      ...(process.platform === 'win32' ? { windowsHide: true } : {}),
+    },
+  );
 }
 
 function killPid(pid: number): boolean {
   try {
     if (process.platform === 'win32') {
-      execFileSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
+      execFileSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
     } else {
       process.kill(pid, 'SIGTERM');
     }
@@ -170,7 +215,7 @@ function getWindowsProcessCommandLine(pid: number): string | null {
       '-ExecutionPolicy', 'Bypass',
       '-Command',
       `(Get-CimInstance Win32_Process -Filter "${pidFilter}").CommandLine`,
-    ], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    ], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true }).trim();
     if (psOut) return psOut;
   } catch {
     // fall through to wmic fallback
@@ -179,7 +224,7 @@ function getWindowsProcessCommandLine(pid: number): string | null {
   try {
     const wmicOut = execFileSync('wmic', [
       'process', 'where', pidFilter, 'get', 'CommandLine',
-    ], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    ], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true }).trim();
     if (wmicOut) return wmicOut;
   } catch {
     // noop
@@ -249,12 +294,11 @@ function removeDaemonPidFile(): void {
 }
 
 function cleanupStaleGlobalInstallDirs(pkgName: string, surface: CurrentGlobalInstallSurface): void {
-  const npmExecOpts = getNpmExecOptions();
   const prefixArgs = surface.installPrefix ? ['--prefix', surface.installPrefix] : [];
-  const npmRoot = 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
-    || execFileSync(surface.npmExecutable, ['prefix', '-g', ...prefixArgs], { encoding: 'utf8', ...npmExecOpts }).trim();
+    || String(execNpmCommandSync(['prefix', '-g', ...prefixArgs], { encoding: 'utf8' }, surface)).trim();
   const binDir = process.platform === 'win32' ? npmPrefix : path.join(npmPrefix, 'bin');
   const packageBaseName = pkgName.startsWith('@') ? pkgName.split('/')[1] : pkgName;
   const binNames = new Set<string>([packageBaseName]);
@@ -331,7 +375,7 @@ async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Prom
       encoding: 'utf8',
       stdio: 'pipe',
       maxBuffer: 20 * 1024 * 1024,
-      ...getNpmExecOptions(),
+      ...installCommand.execOptions,
     },
   );
   if (installOutput.trim()) {

package/src/detection/cli-detector.ts

@@ -60,7 +60,11 @@ function resolveCommandPath(command: string): string | null {
 /** Run a shell command with timeout, returning stdout or null on failure */
 function execAsync(cmd: string, timeoutMs = 5000): Promise<string | null> {
     return new Promise((resolve) => {
-        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()) {
                 resolve(null);
             } else {

package/src/index.d.ts

@@ -41,8 +41,8 @@ export { DaemonCommandHandler } from './commands/handler.js';
 export type { CommandResult, CommandContext } from './commands/handler.js';
 export { DaemonCommandRouter } from './commands/router.js';
 export type { CommandRouterDeps, CommandRouterResult } from './commands/router.js';
-export { maybeRunDaemonUpgradeHelperFromEnv, spawnDetachedDaemonUpgradeHelper, resolveCurrentGlobalInstallSurface, buildPinnedGlobalInstallCommand } from './commands/upgrade-helper.js';
-export type { DaemonUpgradeHelperPayload, CurrentGlobalInstallSurface, PinnedGlobalInstallCommand } from './commands/upgrade-helper.js';
+export { maybeRunDaemonUpgradeHelperFromEnv, spawnDetachedDaemonUpgradeHelper, resolveCurrentGlobalInstallSurface, buildPinnedGlobalInstallCommand, execNpmCommandSync, getNpmExecOptions } from './commands/upgrade-helper.js';
+export type { DaemonUpgradeHelperPayload, CurrentGlobalInstallSurface, PinnedGlobalInstallCommand, NpmExecOptions } from './commands/upgrade-helper.js';
 export { DaemonStatusReporter } from './status/reporter.js';
 export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
 export { buildStatusSnapshot, buildMachineInfo } from './status/snapshot.js';

package/src/index.ts

@@ -140,15 +140,18 @@ export type { CommandResult, CommandContext } from './commands/handler.js';
 export { DaemonCommandRouter } from './commands/router.js';
 export type { CommandRouterDeps, CommandRouterResult } from './commands/router.js';
 export {
-    maybeRunDaemonUpgradeHelperFromEnv,
-    spawnDetachedDaemonUpgradeHelper,
-    resolveCurrentGlobalInstallSurface,
-    buildPinnedGlobalInstallCommand,
+  maybeRunDaemonUpgradeHelperFromEnv,
+  spawnDetachedDaemonUpgradeHelper,
+  resolveCurrentGlobalInstallSurface,
+  buildPinnedGlobalInstallCommand,
+  execNpmCommandSync,
+  getNpmExecOptions,
 } from './commands/upgrade-helper.js';
 export type {
-    DaemonUpgradeHelperPayload,
-    CurrentGlobalInstallSurface,
-    PinnedGlobalInstallCommand,
+  DaemonUpgradeHelperPayload,
+  CurrentGlobalInstallSurface,
+  PinnedGlobalInstallCommand,
+  NpmExecOptions,
 } from './commands/upgrade-helper.js';
 
 // ── Status ──

package/src/launch.ts

@@ -469,7 +469,7 @@ async function launchMacOS(ide: IDEInfo, port: number, workspace?: string, newWi
 
     if (!useAppLauncher && ide.cliCommand) {
  // CLI based execute
-        spawn(ide.cliCommand, args, { detached: true, stdio: 'ignore' }).unref();
+        spawn(ide.cliCommand, args, { detached: true, stdio: 'ignore', windowsHide: true }).unref();
     } else if (appName) {
  // Fallback to `open -a` when no CLI wrapper is available or the provider prefers it.
         const openArgs = ['-a', appName, '--args', ...args];
@@ -509,7 +509,7 @@ async function launchLinux(ide: IDEInfo, port: number, workspace?: string, newWi
     if (newWindow) args.push('--new-window');
     if (workspace) args.push(workspace);
 
-    spawn(cli, args, { detached: true, stdio: 'ignore' }).unref();
+    spawn(cli, args, { detached: true, stdio: 'ignore', windowsHide: true }).unref();
 }
 
 export function getAvailableIdeIds(): string[] {

package/src/providers/acp-provider-instance.ts

@@ -662,6 +662,7 @@ export class AcpProviderInstance implements ProviderInstance {
             env,
             stdio: ['pipe', 'pipe', 'pipe'],
             shell: spawnConfig.shell || false,
+            ...(process.platform === 'win32' ? { windowsHide: true } : {}),
         });
 
  // stderr → log + auth failure detection

package/src/providers/cli-provider-instance.ts

@@ -601,7 +601,12 @@ export class CliProviderInstance implements ProviderInstance {
         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(resolve => setTimeout(resolve, 50));
+                await this.adapter.writeRaw('\r');
+            }
         }
 
         this.applyProviderResponse(parsed.payload, { phase: 'immediate' });

package/src/providers/cli-script-results.ts

@@ -18,7 +18,7 @@ export function parseCliScriptResult(result: unknown): { success: boolean; paylo
   return { success: true, payload: result }
 }
 
-export function getCliScriptCommand(payload: any): { type: string; text?: string } | null {
+export function getCliScriptCommand(payload: any): { type: string; text?: string; enterCount?: number } | null {
   if (!payload || typeof payload !== 'object') return null
 
   if (typeof payload.sendMessage === 'string' && payload.sendMessage.trim()) {
@@ -35,5 +35,8 @@ export function getCliScriptCommand(payload: any): { type: string; text?: 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
+    : undefined
+  return { type: command.type, text, ...(enterCount ? { enterCount } : {}) }
 }