@hybridlabor-api/aos 4.6.4 → 4.6.6

package/bin/aos-config.mjs

@@ -64,8 +64,10 @@ export function propose() {
   };
 }
 
+import { pathToFileURL } from 'node:url';
+
 // ------------------------------------------------------------------- CLI
-if (import.meta.url === `file://${process.argv[1]}`) {
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
   const [cmd, key, ...rest] = process.argv.slice(2);
   const value = rest.join(' ');
 

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 => {
@@ -1864,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}`);
         }
@@ -2017,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 {
@@ -2477,6 +2546,11 @@ function verifyEcosystemInstallation() {
             console.log(`  • ${colors.bold}${mod.name.padEnd(35)}${colors.reset} ➔ ${colors.dim}⚪ Optional / Not downloaded${colors.reset}`);
         }
     }
+
+    console.log('');
+    console.log(`  ${colors.bold}━━━ BDB Agent OS Dashboard ━━━${colors.reset}`);
+    console.log(`  Interactive Control Center: npx aos-dashboard`);
+    console.log(`  ${colors.dim}(Live status & service control at http://127.0.0.1:7900)${colors.reset}`);
 }
 
 function resolveTargetPaths(platformValue, customPaths) {
@@ -3490,6 +3564,51 @@ function installGlobalHooks() {
             log.warn(`Could not install OpenCode plugin: ${e.message}`);
         }
     }
+
+    // 5. Global CLI launcher binaries (aos-config, aos-dashboard, aos-uninstall)
+    installGlobalBinaries();
+}
+
+function installGlobalBinaries() {
+    const binSrc = path.join(srcDir, 'bin');
+    const globalAgentsBin = path.join(homeDir, '.agents', 'bin');
+    if (fs.existsSync(binSrc)) {
+        copyDirRecursiveSync(binSrc, globalAgentsBin);
+        log.step(`Installed CLI binaries to ${globalAgentsBin}`);
+    }
+
+    const localBinDir = path.join(homeDir, '.local', 'bin');
+    if (!fs.existsSync(localBinDir)) {
+        try { fs.mkdirSync(localBinDir, { recursive: true }); } catch (e) { logDebug(e, 'mkdir localBin'); }
+    }
+
+    const isWin = process.platform === 'win32';
+    const cliBins = ['aos-config', 'aos-dashboard', 'aos-uninstall'];
+
+    for (const name of cliBins) {
+        const targetMjs = path.join(globalAgentsBin, `${name}.mjs`);
+        if (!fs.existsSync(targetMjs)) continue;
+
+        // Shell wrapper for Unix / Git Bash
+        const shPath = path.join(localBinDir, name);
+        const shContent = `#!/bin/sh\nexec node "${targetMjs}" "$@"\n`;
+        try {
+            fs.writeFileSync(shPath, shContent, { mode: 0o755 });
+            try { fs.chmodSync(shPath, 0o755); } catch (e) { logDebug(e, `chmod ${shPath}`); }
+        } catch (e) { logDebug(e, `write ${shPath}`); }
+
+        // Windows CMD and PowerShell launchers
+        if (isWin) {
+            const cmdPath = path.join(localBinDir, `${name}.cmd`);
+            const cmdContent = `@echo off\r\nnode "${targetMjs}" %*\r\n`;
+            try { fs.writeFileSync(cmdPath, cmdContent); } catch (e) { logDebug(e, `write ${cmdPath}`); }
+
+            const ps1Path = path.join(localBinDir, `${name}.ps1`);
+            const ps1Content = `node "${targetMjs}" $args\r\n`;
+            try { fs.writeFileSync(ps1Path, ps1Content); } catch (e) { logDebug(e, `write ${ps1Path}`); }
+        }
+    }
+    log.step(`Wired CLI launcher binaries (aos-config, aos-dashboard, aos-uninstall) in ${localBinDir}`);
 }
 
 // Merge the BDB hooks -- the two gates plus the memB ambient-memory hook --
@@ -3885,26 +4004,59 @@ async function promptOptionalModules(installedModules) {
     return chosen;
 }
 
-function generateAndOpenLaunchpad() {
+// Module ids whose daemons ship a web interface or background service worth
+// surfacing in the launchpad (each has a card in the generated HTML below).
+const LAUNCHPAD_WEB_MODULES = ['memb', 'synapse', 'openwiki', 'ao', 'remote'];
+
+// Explicit opt-in flags that open the launchpad even outside a dev checkout.
+const LAUNCHPAD_OPEN_FLAGS = ['--launchpad', '--dashboard', '--open', '--dev'];
+
+// True on a local BDB dev checkout (or BDB_DEV=1). This is intentionally
+// narrower than the old isDevWorkflow check: CLI flags live in
+// shouldOpenLaunchpad(), not here, so callers can tell "dev machine" apart
+// from "user asked for it". Overrides exist for tests.
+function isDevEnvironment(overrides = {}) {
+    const home = overrides.homeDir || homeDir;
+    const env = overrides.env || process.env;
+    return fs.existsSync(path.join(home, 'dev', 'bdb-dev')) ||
+        fs.existsSync(path.join(home, 'bdb-dev')) ||
+        env.BDB_DEV === '1';
+}
+
+// True when the launchpad should be generated and opened: a dev checkout, an
+// explicit flag, or installed daemon/WebUI modules. Overrides exist for tests.
+function shouldOpenLaunchpad(installedModules = [], overrides = {}) {
+    const argv = overrides.argv || process.argv;
+    if (isDevEnvironment(overrides)) return true;
+    if (LAUNCHPAD_OPEN_FLAGS.some(f => argv.includes(f))) return true;
+    const installed = Array.isArray(installedModules) ? installedModules : [];
+    return installed.some(m => LAUNCHPAD_WEB_MODULES.includes(m));
+}
+
+// Boot autostart (login item) is opt-in only: an explicit flag or a dev
+// checkout. Regular end-user installs must not get an autostart entry that
+// opens a browser on every login. Overrides exist for tests.
+function shouldAutostartLaunchpad(overrides = {}) {
+    const argv = overrides.argv || process.argv;
+    if (argv.includes('--autostart-launchpad')) return true;
+    return isDevEnvironment(overrides);
+}
+
+function generateAndOpenLaunchpad(installedModules = []) {
     if (DRY_RUN) {
         log.step('[dry-run] would generate & open BDB Launchpad HTML');
-        return;
+        return false;
     }
-    if (process.env.SSH_CLIENT || process.env.SSH_TTY) return;
+    if (process.env.SSH_CLIENT || process.env.SSH_TTY) return false;
 
-    // Local Developer Workflow Guard:
-    // Only generate and open the launchpad if running in a local developer repo environment or explicitly requested.
+    // Decoupled from the dev-checkout layout: on a regular end-user machine
+    // (no ~/dev/bdb-dev, no ~/bdb-dev) the launchpad still opens when daemon
+    // modules are installed or an explicit flag was passed.
     // ~/bdb-dev was the pre-reorg workspace root; the State-0 reorg moved it to
-    // ~/dev/bdb-dev, but this check was never updated -- it has been silently
-    // false on every real dev machine since that reorg. Checking both keeps
-    // this working regardless of which layout a given machine still has.
-    const isDevWorkflow = fs.existsSync(path.join(homeDir, 'dev', 'bdb-dev')) ||
-                          fs.existsSync(path.join(homeDir, 'bdb-dev')) ||
-                          process.env.BDB_DEV === '1' ||
-                          process.argv.includes('--launchpad') ||
-                          process.argv.includes('--dev');
-    if (!isDevWorkflow) {
-        return;
+    // ~/dev/bdb-dev. Both are checked so this works regardless of which layout
+    // a given machine still has.
+    if (!shouldOpenLaunchpad(installedModules)) {
+        return false;
     }
 
     const html = `<!DOCTYPE html>
@@ -4240,6 +4392,12 @@ function generateAndOpenLaunchpad() {
     // own background services, but the dashboard itself (a static file, not
     // a process) never got the equivalent: something to open it automatically
     // on login too, not just right after an installer run.
+    // Opt-in only: without --autostart-launchpad (or a dev checkout) a regular
+    // end-user install must not drop a login item that opens a browser on
+    // every boot.
+    if (!shouldAutostartLaunchpad()) {
+        return true;
+    }
     if (process.platform === 'darwin') {
         const plistPath = path.join(homeDir, 'Library', 'LaunchAgents', 'com.bdb.launchpad.plist');
         const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
@@ -4275,9 +4433,10 @@ function generateAndOpenLaunchpad() {
             fs.writeFileSync(vbsPath, vbsContent, 'utf-8');
         } catch (e) { logDebug(e, 'launchpad autostart vbs'); }
     }
+    return true;
 }
 
-async function universalHarnessSync(primaryMcpConfigPath) {
+async function universalHarnessSync(primaryMcpConfigPath, installedModules = []) {
     log.info('Universal Agent Harness Sync...');
     const detections = detectPlatforms();
     let masterMcpData = {};
@@ -4439,7 +4598,7 @@ async function universalHarnessSync(primaryMcpConfigPath) {
         }
     }
     log.success('Universal Sync Complete!');
-    generateAndOpenLaunchpad();
+    generateAndOpenLaunchpad(installedModules);
 }
 
 async function runQuickUpdate(installState) {
@@ -4545,7 +4704,7 @@ async function runQuickUpdate(installState) {
     // did, so a dev-workflow machine only ever saw it once, on day one --
     // every subsequent run is a Quick Update, which is what almost every
     // real run after the first actually is.
-    generateAndOpenLaunchpad();
+    generateAndOpenLaunchpad(modulesToUpdate);
 }
 
 
@@ -4944,7 +5103,7 @@ async function main() {
     saveManifest({ tier, isUniversal: wantsUniversal, installedModules: installedModulesForPrompt });
 
     if (wantsUniversal) {
-        await universalHarnessSync(primaryTarget.mcpConfigPath);
+        await universalHarnessSync(primaryTarget.mcpConfigPath, installedModulesForPrompt);
     }
 
     // Flush file-level install manifest after all writes are done.
@@ -4992,4 +5151,11 @@ module.exports = {
     loadPipelineConfig,
     resolveAgentConfig,
     CANONICAL_TIERS,
+    // Launchpad lifecycle (exported for regression tests)
+    generateAndOpenLaunchpad,
+    shouldOpenLaunchpad,
+    shouldAutostartLaunchpad,
+    isDevEnvironment,
+    LAUNCHPAD_WEB_MODULES,
+    LAUNCHPAD_OPEN_FLAGS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hybridlabor-api/aos",
-  "version": "4.6.4",
+  "version": "4.6.6",
   "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": {

package/skills/global_config/aos-project-init/scripts/aos-project-doctor.mjs

@@ -55,6 +55,17 @@ function checkGit() {
 
 // ---------------------------------------------------------------- aos config
 function checkAosConfig() {
+  const machineConfig = (() => {
+    try { return JSON.parse(readFileSync(path.join(HOME, '.agents', 'aos-config.json'), 'utf8')); }
+    catch { return null; }
+  })();
+  const machineOk = !!(machineConfig?.workspaceRoot && machineConfig?.domains?.length && machineConfig?.userId);
+  add('aos', 'machine vocabulary', machineOk,
+    machineOk
+      ? `workspaceRoot "${machineConfig.workspaceRoot}" · ${machineConfig.domains.length} domains · userId "${machineConfig.userId}"`
+      : 'missing or incomplete in ~/.agents/aos-config.json — /aos-project-init requires machine vocabulary',
+    'Run /aos-setup (or `aos-config propose` / `aos-config set`) to configure machine vocabulary.');
+
   add('aos', '.aos/project.json', !!aosConfig,
     aosConfig
       ? `slug "${aosConfig.slug}"${aosConfig.domain ? ` · domain ${aosConfig.domain}` : ''}${aosConfig.watch ? ' · überwacht' : ''}`