@hybridlabor-api/aos 4.6.3 → 4.6.5

package/bin/aos-dashboard.mjs

@@ -4,9 +4,10 @@
 //
 //   aos-dashboard [--port 7900] [--no-open]
 //
-// Binds to 127.0.0.1 only. Control actions run launchctl against a fixed
-// service table — the request never reaches a shell, and an id that is not in
-// the table is refused, so nothing a browser sends can widen what this can do.
+// Binds to 127.0.0.1 only. Control actions run against a fixed service table
+// using launchctl on macOS or the corresponding Windows service wrapper/task —
+// the request never reaches a shell, and an id that is not in the table is
+// refused, so nothing a browser sends can widen what this can do.
 
 import { createServer } from 'node:http';
 import { connect, createServer as createTcpServer } from 'node:net';
@@ -22,6 +23,9 @@ const execFileP = promisify(execFile);
 const HOME = os.homedir();
 const h = (...p) => path.join(HOME, ...p);
 const IS_MAC = process.platform === 'darwin';
+const WINDOWS_STARTUP_DIR = process.env.APPDATA
+  ? path.join(process.env.APPDATA, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup')
+  : h('AppData', 'Roaming', 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup');
 const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const BRAND_DIR = path.join(PKG_ROOT, 'assets', 'brand');
 
@@ -104,6 +108,14 @@ const SERVICES = [
 
 const byId = new Map(SERVICES.map((s) => [s.id, s]));
 
+// Windows uses the VBS wrappers installed by the AOS installer for memB and
+// Synapse. The process patterns are constants, never request data, so the
+// dashboard cannot be turned into an arbitrary process launcher.
+const WINDOWS_DAEMONS = {
+  memb: { vbs: 'com.bdb.memb.webui.vbs', processPattern: 'src[\\\\/]backend[\\\\/]server\\.py' },
+  synapse: { vbs: 'com.bdb.synapse.vbs', processPattern: 'synapse\\.js.*serve' },
+};
+
 // ------------------------------------------------------------------ probing
 function portOpen(port, timeout = 800) {
   return new Promise((resolve) => {
@@ -127,11 +139,23 @@ const freePort = () => new Promise((resolve, reject) => {
 });
 
 async function agentLoaded(label) {
-  if (!IS_MAC) return null;
-  try {
-    const { stdout } = await execFileP('launchctl', ['list']);
-    return stdout.split('\n').some((l) => l.trim().endsWith(label));
-  } catch { return null; }
+  if (IS_MAC) {
+    try {
+      const { stdout } = await execFileP('launchctl', ['list']);
+      return stdout.split('\n').some((l) => l.trim().endsWith(label));
+    } catch { return null; }
+  }
+  if (process.platform === 'win32' && label === 'com.bdb.openwiki.daemon') {
+    try {
+      const { stdout } = await execFileP('powershell.exe', [
+        '-NoProfile', '-Command',
+        "$task = Get-ScheduledTask -TaskName 'BDB_OpenWiki_Daemon' -ErrorAction SilentlyContinue; if ($task) { $task.State }",
+      ], { timeout: 5000 });
+      const state = stdout.trim();
+      return state === 'Ready' || state === 'Running';
+    } catch { return null; }
+  }
+  return null;
 }
 
 const localVersion = (dir) => {
@@ -300,7 +324,42 @@ async function control(id, action) {
   const svc = byId.get(id);
   if (!svc) throw new Error('unknown service');
   if (!['start', 'stop', 'restart'].includes(action)) throw new Error('unknown action');
-  if (!IS_MAC) throw new Error('start/stop is wired for launchd (macOS) only');
+
+  if (process.platform === 'win32' && id === 'openwiki') {
+    // OpenWiki's refresh daemon is registered as a Scheduled Task on Windows,
+    // not as a launchd plist. Keep the command allowlisted and pass only a
+    // constant task name to PowerShell; browser input never becomes a command.
+    const run = (command) => execFileP('powershell.exe', [
+      '-NoProfile', '-Command', command,
+    ], { timeout: 10000 }).catch((e) => { throw new Error(e.stderr?.trim() || e.message); });
+    const task = "'BDB_OpenWiki_Daemon'";
+    if (action === 'stop' || action === 'restart') {
+      await run(`Stop-ScheduledTask -TaskName ${task} -ErrorAction SilentlyContinue`);
+    }
+    if (action === 'start' || action === 'restart') {
+      await run(`Start-ScheduledTask -TaskName ${task} -ErrorAction Stop`);
+    }
+    return { ok: true };
+  }
+
+  if (process.platform === 'win32' && WINDOWS_DAEMONS[id]) {
+    const daemon = WINDOWS_DAEMONS[id];
+    const vbsPath = path.join(WINDOWS_STARTUP_DIR, daemon.vbs);
+    if (!existsSync(vbsPath)) throw new Error(`no Windows startup wrapper installed for ${svc.name}`);
+    const run = (command) => execFileP('powershell.exe', [
+      '-NoProfile', '-Command', command,
+    ], { timeout: 10000 }).catch((e) => { throw new Error(e.stderr?.trim() || e.message); });
+    if (action === 'stop' || action === 'restart') {
+      const escapedPattern = daemon.processPattern.replace(/'/g, "''");
+      await run(`Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -and $_.CommandLine -match '${escapedPattern}' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }`);
+    }
+    if (action === 'start' || action === 'restart') {
+      await execFileP('wscript.exe', [vbsPath], { timeout: 10000 });
+    }
+    return { ok: true };
+  }
+
+  if (!IS_MAC) throw new Error('start/stop is not available on this platform for this service');
 
   const plist = h('Library', 'LaunchAgents', `${svc.agent}.plist`);
   if (!existsSync(plist)) throw new Error(`no LaunchAgent installed for ${svc.name}`);

package/installer.js

@@ -241,6 +241,42 @@ function hasExecutable(binary) {
     }
 }
 
+// Windows installers launched from an existing terminal can inherit a stale
+// PATH after Go was installed through winget or the official installer. The
+// Synapse JS launcher shells out to Go on first run, so discover the standard
+// install locations as well as PATH and persist the resolved bin directory in
+// the generated startup wrapper.
+function findWindowsGoBin() {
+    if (process.platform !== 'win32') return null;
+    const candidates = [];
+    try {
+        const found = execSync('where.exe go', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+            .split(/\r?\n/).map(s => s.trim()).find(Boolean);
+        if (found) candidates.push(path.dirname(found));
+    } catch (_) { /* PATH can be stale immediately after installation */ }
+
+    const roots = [
+        process.env.GOROOT,
+        process.env.ProgramW6432,
+        process.env.ProgramFiles,
+        process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Programs') : null,
+    ].filter(Boolean);
+    for (const root of roots) {
+        candidates.push(path.join(root, 'Go', 'bin'));
+        candidates.push(path.join(root, 'go', 'bin'));
+    }
+    return candidates.find(dir => fs.existsSync(path.join(dir, 'go.exe'))) || null;
+}
+
+function verifyPythonImports(pythonPath, cwd, importCode) {
+    const result = spawnSync(pythonPath, ['-c', importCode], {
+        cwd,
+        stdio: 'ignore',
+        timeout: 30000,
+    });
+    return !result.error && result.status === 0;
+}
+
 function resolveUnsupportedMcpConfigKeys() {
     const keys = unsupportedMcpConfigKeys.slice();
     conditionalMcpConfigKeys.forEach(entry => {
@@ -1072,6 +1108,15 @@ function moveIfExists(src, dest, label) {
     }
 }
 
+function safeRmDirSync(dirPath, maxRetries = 5, retryDelay = 200) {
+    if (!dirPath || !fs.existsSync(dirPath)) return;
+    try {
+        fs.rmSync(dirPath, { recursive: true, force: true, maxRetries, retryDelay });
+    } catch (err) {
+        logDebug(err, `safeRmDirSync: ${dirPath}`);
+    }
+}
+
 function copyDirRecursiveSync(source, target, excludeList = [], manifest = null, knownSourceHashes = null) {
     // Fall back to session-level state when no explicit manifest is passed.
     const mfst = manifest !== null ? manifest : _sessionManifest;
@@ -1722,7 +1767,21 @@ function downloadOrUpdateModule(pkgName, targetDir, displayName) {
         // kept until the swap succeeds, and restored if it does not.
         const stagingDir = `${targetDir}.incoming-${timestamp}`;
         const retiredDir = `${targetDir}.previous-${timestamp}`;
-        fs.rmSync(stagingDir, { recursive: true, force: true });
+
+        // Clean up any stale staging or retired directories left behind by earlier interrupted runs
+        try {
+            const parentDir = path.dirname(targetDir);
+            const baseName = path.basename(targetDir);
+            if (fs.existsSync(parentDir)) {
+                for (const item of fs.readdirSync(parentDir)) {
+                    if (item.startsWith(`${baseName}.incoming-`) || item.startsWith(`${baseName}.previous-`)) {
+                        safeRmDirSync(path.join(parentDir, item));
+                    }
+                }
+            }
+        } catch (_) {}
+
+        safeRmDirSync(stagingDir);
         fs.mkdirSync(stagingDir, { recursive: true });
         execSync(`tar -xzf "${path.join(targetDir, tarball)}" --strip-components=1 -C "${stagingDir}"`, { stdio: 'ignore' });
         fs.unlinkSync(path.join(targetDir, tarball));
@@ -1733,7 +1792,11 @@ function downloadOrUpdateModule(pkgName, targetDir, displayName) {
         for (const keep of PRESERVE) {
             const from = path.join(targetDir, keep);
             if (fs.existsSync(from) && !fs.existsSync(path.join(stagingDir, keep))) {
-                fs.renameSync(from, path.join(stagingDir, keep));
+                try {
+                    fs.renameSync(from, path.join(stagingDir, keep));
+                } catch (preserveErr) {
+                    logDebug(preserveErr, `preserve ${keep}`);
+                }
             }
         }
 
@@ -1741,11 +1804,17 @@ function downloadOrUpdateModule(pkgName, targetDir, displayName) {
             fs.renameSync(targetDir, retiredDir);
             fs.renameSync(stagingDir, targetDir);
         } catch (swapError) {
-            if (fs.existsSync(retiredDir) && !fs.existsSync(targetDir)) fs.renameSync(retiredDir, targetDir);
-            fs.rmSync(stagingDir, { recursive: true, force: true });
+            if (fs.existsSync(retiredDir) && !fs.existsSync(targetDir)) {
+                try { fs.renameSync(retiredDir, targetDir); } catch (_) {}
+            }
+            safeRmDirSync(stagingDir);
             throw swapError;
         }
-        fs.rmSync(retiredDir, { recursive: true, force: true });
+
+        // On Windows especially, deleting a directory that was just renamed or contains
+        // locked file handles can throw EPERM / EBUSY. Since targetDir already has the
+        // new version in place, failure to clean up retiredDir must be non-fatal.
+        safeRmDirSync(retiredDir);
 
         s.stop(`${displayName} ready (v${status.remoteVer || 'latest'})`);
         return true;
@@ -1810,6 +1879,17 @@ async function installMemB(interactive) {
             if (!hasUv) {
                 try { execSync('uv --version', { stdio: 'ignore' }); hasUv = true; } catch (e) { hasUv = false; }
             }
+            if (!hasUv && fs.existsSync(venvPython)) {
+                try {
+                    execSync(`"${venvPython}" -m pip --version`, { stdio: 'ignore' });
+                } catch (_) {
+                    try {
+                        execSync(`"${venvPython}" -m ensurepip --default-pip`, { cwd: membDir, stdio: 'ignore' });
+                    } catch (ePip) {
+                        logDebug(ePip, 'ensurepip bootstrap for memB');
+                    }
+                }
+            }
             const uvInstall = (pkgsArg) => `uv pip install --python "${venvPython}" ${pkgsArg}`;
             const pipInstall = (pkgsArg) => `"${venvPython}" -m pip install ${pkgsArg} --timeout 30 --no-input`;
             const installCmd = (pkgsArg) => hasUv ? uvInstall(pkgsArg) : pipInstall(pkgsArg);
@@ -1820,6 +1900,30 @@ async function installMemB(interactive) {
             if (installWebUI && fs.existsSync(serverPy)) {
                 runPipWithRetry(installCmd('fastapi uvicorn'), { cwd: membDir, stdio: 'ignore' }, 'pip fastapi+uvicorn for memB WebUI', 2, 120000);
             }
+
+            // A partially upgraded venv can contain pydantic while missing or
+            // mismatching pydantic-core. That failure only appears later when
+            // the WebUI imports its models, so validate the actual interpreter
+            // before registering the daemon and repair the pair in place.
+            const importCheck = installWebUI && fs.existsSync(serverPy)
+                ? 'import pydantic, pydantic_core; from fastapi import FastAPI; import uvicorn'
+                : 'import pydantic, pydantic_core';
+            if (!verifyPythonImports(venvPython, membDir, importCheck)) {
+                log.warn('memB Python dependencies are inconsistent; repairing pydantic and pydantic-core.');
+                const repairPackages = installWebUI && fs.existsSync(serverPy)
+                    ? '--force-reinstall "pydantic>=2.7.3" "pydantic-core>=2.18.4" fastapi uvicorn'
+                    : '--force-reinstall "pydantic>=2.7.3" "pydantic-core>=2.18.4"';
+                const repaired = runPipWithRetry(
+                    installCmd(repairPackages),
+                    { cwd: membDir, stdio: 'inherit' },
+                    'repair memB Python dependencies',
+                    2,
+                    900000,
+                );
+                if (repaired && !verifyPythonImports(venvPython, membDir, importCheck)) {
+                    log.warn('memB dependency repair did not pass the import check; inspect the venv before starting the daemon.');
+                }
+            }
         } catch (e) {
             log.warn(`Failed memB standalone venv setup: ${e.message}`);
         }
@@ -1973,11 +2077,20 @@ async function installSynapse() {
             const stderrLog = path.join(synapseLogDir, 'daemon.stderr.log');
             const batPath = path.join(synapseLogDir, 'run-synapse.bat');
             const runCmd = binaryPath.endsWith('.js') ? `node "${binaryPath}" serve --port 7781` : `"${binaryPath}" serve --port 7781`;
+            const goBin = binaryPath.endsWith('.js') ? findWindowsGoBin() : null;
+            if (binaryPath.endsWith('.js') && goBin) {
+                log.step(`Synapse Windows wrapper will use Go from ${goBin}`);
+            } else if (binaryPath.endsWith('.js')) {
+                log.warn('Synapse Windows launcher requires Go on first run; install Go from https://go.dev/dl/ before starting the daemon.');
+            }
             // WshShell.Run has no stdout/stderr redirection of its own, so a crash on launch
             // (e.g. a missing dependency the binary shells out to) used to die silently with
             // nothing to diagnose short of reading source — route through a .bat wrapper that
             // redirects to the same ~/.synapse log files the macOS launchd plist already writes.
-            const batContent = `@echo off\r\ncd /d "${synapseDir}"\r\n${runCmd} >> "${stdoutLog}" 2>> "${stderrLog}"\r\n`;
+            const goSetup = goBin
+                ? `set "PATH=${goBin.replace(/%/g, '%%')};%PATH%"\r\n`
+                : `where.exe go >nul 2>&1 || (echo Go is required by the Synapse launcher. Install it from https://go.dev/dl/ and restart this daemon. >> "${stderrLog}" & exit /b 1)\r\n`;
+            const batContent = `@echo off\r\n${goSetup}cd /d "${synapseDir}"\r\n${runCmd} >> "${stdoutLog}" 2>> "${stderrLog}"\r\n`;
             const vbsPath = path.join(startupDir, 'com.bdb.synapse.vbs');
             const vbsContent = `Set WshShell = CreateObject("WScript.Shell")\r\nWshShell.CurrentDirectory = "${synapseDir}"\r\nWshShell.Run """${batPath}""", 0, False\r\n`;
             try {
@@ -2076,11 +2189,12 @@ async function installOpenWikiVisualizer() {
     const ecosystemWiki = path.join(homeDir, '.openwiki', 'ecosystem-wiki');
     const syncScript = path.join(srcDir, 'skills', 'global_config', 'openwiki-skill', 'scripts', 'sync_ecosystem_wiki.py');
     if (!wikiPath) {
+        const pyBin = hasExecutable('python3') ? 'python3' : hasExecutable('python') ? 'python' : null;
         if (looksLikeWiki(ecosystemWiki)) {
             wikiPath = ecosystemWiki;
-        } else if (fs.existsSync(syncScript) && hasExecutable('python3')) {
+        } else if (fs.existsSync(syncScript) && pyBin) {
             try {
-                execSync(`python3 "${syncScript}"`, { stdio: 'ignore' });
+                execSync(`"${pyBin}" "${syncScript}"`, { stdio: 'ignore' });
                 if (looksLikeWiki(ecosystemWiki)) wikiPath = ecosystemWiki;
             } catch (e) { logDebug(e, 'ecosystem wiki sync'); }
         }
@@ -2091,6 +2205,9 @@ async function installOpenWikiVisualizer() {
             });
             if (!isCancel(answer) && answer && answer.trim()) {
                 const candidate = answer.trim().replace(/^~(?=$|\/|\\)/, homeDir);
+                if (!fs.existsSync(candidate)) {
+                    try { fs.mkdirSync(candidate, { recursive: true }); } catch (_) {}
+                }
                 if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
                     wikiPath = candidate;
                     if (!looksLikeWiki(candidate)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hybridlabor-api/aos",
-  "version": "4.6.3",
+  "version": "4.6.5",
   "description": "AOS — A Curated AI AGENT OS. Optimized agent skills and add-ons like memB, OpenWiki, Heimdall Token Saver, and Godmode architectures.",
   "main": "installer.js",
   "engines": {