@adhdev/daemon-core 0.7.43 → 0.7.44

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.7.43",
+  "version": "0.7.44",
   "description": "ADHDev local session host core — session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.7.43",
+  "version": "0.7.44",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/router.ts

@@ -26,6 +26,7 @@ import { logCommand } from '../logging/command-log.js';
 import { getRecentLogs, LOG_PATH } from '../logging/logger.js';
 import { buildSessionEntries } from '../status/builders.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
+import { spawnDetachedDaemonUpgradeHelper } from './upgrade-helper.js';
 import * as fs from 'fs';
 
 // ─── Types ───
@@ -315,36 +316,41 @@ export class DaemonCommandRouter {
                     // Check latest version
                     const latest = execSync(`npm view ${pkgName} version`, { encoding: 'utf-8', timeout: 10000 }).trim();
                     LOG.info('Upgrade', `Latest ${pkgName}: v${latest}`);
+                    let currentInstalled: string | null = null;
+                    try {
+                        const currentJson = execSync(`npm ls -g ${pkgName} --depth=0 --json`, {
+                            encoding: 'utf-8',
+                            timeout: 10000,
+                            stdio: ['pipe', 'pipe', 'pipe'],
+                        }).trim();
+                        const parsed = JSON.parse(currentJson);
+                        currentInstalled = parsed?.dependencies?.[pkgName]?.version || null;
+                    } catch {
+                        // ignore ls failures; upgrade can still proceed
+                    }
 
-                    // Install latest (--force ensures native addons are rebuilt cleanly)
-                    execSync(`npm install -g ${pkgName}@latest --force`, {
-                        encoding: 'utf-8',
-                        timeout: 120000,
-                        stdio: ['pipe', 'pipe', 'pipe'],
+                    if (currentInstalled === latest) {
+                        LOG.info('Upgrade', `Already on latest version v${latest}; skipping install`);
+                        return { success: true, upgraded: false, alreadyLatest: true, version: latest };
+                    }
+
+                    spawnDetachedDaemonUpgradeHelper({
+                        packageName: pkgName,
+                        targetVersion: latest,
+                        parentPid: process.pid,
+                        restartArgv: process.argv.slice(1),
+                        cwd: process.cwd(),
+                        sessionHostAppName: process.env.ADHDEV_SESSION_HOST_NAME || 'adhdev',
                     });
-                    LOG.info('Upgrade', `✅ Upgraded to v${latest}`);
+                    LOG.info('Upgrade', `Scheduled detached upgrade to v${latest}`);
 
-                    // Schedule restart after response is sent
+                    // Exit after the command response has been sent so the helper can replace the package cleanly.
                     setTimeout(() => {
-                        LOG.info('Upgrade', 'Restarting daemon with new version...');
-                        // Remove PID file so the new process doesn't see 'already running'
-                        try {
-                            const path = require('path');
-                            const fs = require('fs');
-                            const pidFile = path.join(process.env.HOME || process.env.USERPROFILE || '', '.adhdev', 'daemon.pid');
-                            if (fs.existsSync(pidFile)) fs.unlinkSync(pidFile);
-                        } catch { /* ignore */ }
-                        const { spawn } = require('child_process');
-                        const child = spawn(process.execPath, process.argv.slice(1), {
-                            detached: true,
-                            stdio: 'ignore',
-                            env: { ...process.env },
-                        });
-                        child.unref();
+                        LOG.info('Upgrade', 'Exiting daemon so detached upgrader can continue...');
                         process.exit(0);
                     }, 3000);
 
-                    return { success: true, upgraded: true, version: latest };
+                    return { success: true, upgraded: true, version: latest, restarting: true };
                 } catch (e: any) {
                     LOG.error('Upgrade', `Failed: ${e.message}`);
                     return { success: false, error: e.message };

package/src/commands/upgrade-helper.ts

@@ -0,0 +1,214 @@
+import { execFileSync } from 'child_process';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+const UPGRADE_HELPER_ENV = 'ADHDEV_DAEMON_UPGRADE_HELPER';
+
+export interface DaemonUpgradeHelperPayload {
+  packageName: string;
+  targetVersion: string;
+  parentPid: number;
+  restartArgv: string[];
+  cwd?: string;
+  sessionHostAppName?: string;
+}
+
+function getUpgradeLogPath(): string {
+  const home = os.homedir();
+  const dir = path.join(home, '.adhdev');
+  fs.mkdirSync(dir, { recursive: true });
+  return path.join(dir, 'daemon-upgrade.log');
+}
+
+function appendUpgradeLog(message: string): void {
+  const line = `[${new Date().toISOString()}] ${message}\n`;
+  try {
+    fs.appendFileSync(getUpgradeLogPath(), line, 'utf8');
+  } catch {
+    // noop
+  }
+}
+
+function getNpmExecutable(): string {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function killPid(pid: number): boolean {
+  try {
+    if (process.platform === 'win32') {
+      execFileSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
+    } else {
+      process.kill(pid, 'SIGTERM');
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitForPidExit(pid: number, timeoutMs: number): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      process.kill(pid, 0);
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    } catch {
+      return;
+    }
+  }
+}
+
+function stopSessionHostProcesses(appName: string): void {
+  const pidFile = path.join(os.homedir(), '.adhdev', `${appName}-session-host.pid`);
+  try {
+    if (fs.existsSync(pidFile)) {
+      const pid = Number.parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+      if (Number.isFinite(pid)) {
+        killPid(pid);
+      }
+    }
+  } catch {
+    // noop
+  } finally {
+    try {
+      fs.unlinkSync(pidFile);
+    } catch {
+      // noop
+    }
+  }
+
+  if (process.platform !== 'win32') {
+    try {
+      const raw = execFileSync('pgrep', ['-f', 'session-host-daemon'], { encoding: 'utf8' }).trim();
+      for (const line of raw.split('\n')) {
+        const pid = Number.parseInt(line.trim(), 10);
+        if (Number.isFinite(pid)) {
+          killPid(pid);
+        }
+      }
+    } catch {
+      // noop
+    }
+  }
+}
+
+function removeDaemonPidFile(): void {
+  const pidFile = path.join(os.homedir(), '.adhdev', 'daemon.pid');
+  try {
+    fs.unlinkSync(pidFile);
+  } catch {
+    // noop
+  }
+}
+
+function cleanupStaleGlobalInstallDirs(pkgName: string): void {
+  const npmRoot = execFileSync(getNpmExecutable(), ['root', '-g'], { encoding: 'utf8' }).trim();
+  if (!npmRoot) return;
+  const npmPrefix = execFileSync(getNpmExecutable(), ['prefix', '-g'], { encoding: 'utf8' }).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]);
+  if (pkgName === '@adhdev/daemon-standalone') {
+    binNames.add('adhdev-standalone');
+  }
+
+  if (pkgName.startsWith('@')) {
+    const [scope, name] = pkgName.split('/');
+    const scopeDir = path.join(npmRoot, scope);
+    if (!fs.existsSync(scopeDir)) return;
+    for (const entry of fs.readdirSync(scopeDir)) {
+      if (!entry.startsWith(`.${name}-`)) continue;
+      fs.rmSync(path.join(scopeDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale scoped staging dir: ${path.join(scopeDir, entry)}`);
+    }
+  } else {
+    for (const entry of fs.readdirSync(npmRoot)) {
+      if (!entry.startsWith(`.${pkgName}-`)) continue;
+      fs.rmSync(path.join(npmRoot, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale staging dir: ${path.join(npmRoot, entry)}`);
+    }
+  }
+
+  if (fs.existsSync(binDir)) {
+    for (const entry of fs.readdirSync(binDir)) {
+      if (![...binNames].some((name) => entry.startsWith(`.${name}-`))) continue;
+      fs.rmSync(path.join(binDir, entry), { recursive: true, force: true });
+      appendUpgradeLog(`Removed stale bin staging entry: ${path.join(binDir, entry)}`);
+    }
+  }
+}
+
+export function spawnDetachedDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): void {
+  const env = { ...process.env, [UPGRADE_HELPER_ENV]: JSON.stringify(payload) };
+  const child = spawn(process.execPath, process.argv.slice(1), {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    cwd: payload.cwd || process.cwd(),
+    env,
+  });
+  child.unref();
+}
+
+async function runDaemonUpgradeHelper(payload: DaemonUpgradeHelperPayload): Promise<void> {
+  const restartArgv = Array.isArray(payload.restartArgv) ? payload.restartArgv : [];
+  const sessionHostAppName = payload.sessionHostAppName || process.env.ADHDEV_SESSION_HOST_NAME || 'adhdev';
+  appendUpgradeLog(`Upgrade helper started for ${payload.packageName}@${payload.targetVersion}`);
+
+  if (Number.isFinite(payload.parentPid) && payload.parentPid > 0) {
+    appendUpgradeLog(`Waiting for parent pid ${payload.parentPid} to exit`);
+    await waitForPidExit(payload.parentPid, 15000);
+  }
+
+  stopSessionHostProcesses(sessionHostAppName);
+  removeDaemonPidFile();
+  cleanupStaleGlobalInstallDirs(payload.packageName);
+
+  const spec = `${payload.packageName}@${payload.targetVersion || 'latest'}`;
+  appendUpgradeLog(`Installing ${spec}`);
+  const installOutput = execFileSync(
+    getNpmExecutable(),
+    ['install', '-g', spec, '--force'],
+    {
+      encoding: 'utf8',
+      stdio: 'pipe',
+      maxBuffer: 20 * 1024 * 1024,
+    },
+  );
+  if (installOutput.trim()) {
+    appendUpgradeLog(installOutput.trim());
+  }
+
+  if (restartArgv.length > 0) {
+    const env = { ...process.env };
+    delete env[UPGRADE_HELPER_ENV];
+    appendUpgradeLog(`Restarting daemon with args: ${restartArgv.join(' ')}`);
+    const child = spawn(process.execPath, restartArgv, {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+      cwd: payload.cwd || process.cwd(),
+      env,
+    });
+    child.unref();
+  } else {
+    appendUpgradeLog('No restart argv provided; upgrade completed without restart');
+  }
+}
+
+export async function maybeRunDaemonUpgradeHelperFromEnv(): Promise<boolean> {
+  const raw = process.env[UPGRADE_HELPER_ENV];
+  if (!raw) return false;
+  delete process.env[UPGRADE_HELPER_ENV];
+
+  try {
+    const payload = JSON.parse(raw) as DaemonUpgradeHelperPayload;
+    await runDaemonUpgradeHelper(payload);
+    process.exit(0);
+  } catch (error: any) {
+    appendUpgradeLog(`Upgrade helper failed: ${error?.stack || error?.message || String(error)}`);
+    process.exit(1);
+  }
+}

package/src/index.ts

@@ -89,6 +89,7 @@ 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 } from './commands/upgrade-helper.js';
 
 // ── Status ──
 export { DaemonStatusReporter } from './status/reporter.js';