@openagents-org/agent-launcher 0.2.109 → 0.2.111

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-launcher",
-  "version": "0.2.109",
+  "version": "0.2.111",
   "description": "OpenAgents Launcher — install, configure, and run AI coding agents from your terminal",
   "main": "src/index.js",
   "bin": {

package/registry.json

@@ -136,16 +136,27 @@
       {
         "name": "OPENAI_API_KEY",
         "description": "OpenAI API key",
-        "required": true,
+        "required": false,
         "password": true
+      },
+      {
+        "name": "OPENAI_BASE_URL",
+        "description": "OpenAI-compatible base URL",
+        "required": false
       }
     ],
     "check_ready": {
-      "env_vars": [
-        "OPENAI_API_KEY"
+      "env_all": [
+        "OPENAI_API_KEY",
+        "OPENAI_BASE_URL"
       ],
-      "saved_env_key": "OPENAI_API_KEY",
-      "not_ready_message": "No API key \u2014 press e to configure"
+      "saved_env_all": [
+        "OPENAI_API_KEY",
+        "OPENAI_BASE_URL"
+      ],
+      "status_command": "codex login status",
+      "login_command": "codex login",
+      "not_ready_message": "Not configured. Set OPENAI_API_KEY + OPENAI_BASE_URL, or run: codex login"
     },
     "resolve_env": {
       "rules": [
@@ -525,4 +536,4 @@
       "windows": "pip install sweagent"
     }
   }
-]
+]

package/src/adapters/claude.js

@@ -272,72 +272,56 @@ class ClaudeAdapter extends BaseAdapter {
     if (this.disabledModules.has('files')) mcpArgs.push('--disable-files');
     if (this.disabledModules.has('browser')) mcpArgs.push('--disable-browser');
 
-    // Find openagents binary (multi-tier)
-    let oaBin = null;
-    const home3 = os.homedir();
-    // Tier 0: Check all isolated runtime prefixes for openagents binary
-    const oaExt = IS_WINDOWS ? '.cmd' : '';
-    const runtimesRoot = path.join(home3, '.openagents', 'runtimes');
-    try {
-      for (const d of fs.readdirSync(runtimesRoot, { withFileTypes: true })) {
-        if (d.isDirectory()) {
-          const candidate = path.join(runtimesRoot, d.name, 'node_modules', '.bin', `openagents${oaExt}`);
-          if (fs.existsSync(candidate)) { oaBin = candidate; break; }
+    // Resolve the MCP server entry point. Prefer the sibling bin inside this
+    // very package — it's guaranteed to exist whenever claude.js is executing,
+    // so it never falls through to a broken PATH lookup. If Claude Code can't
+    // spawn the MCP server, it silently hides every workspace tool and the
+    // agent reports "workspace_read_file isn't in my tool set".
+    let mcpCommand = this._findNodeBin();
+    let mcpFinalArgs = mcpArgs;
+    const siblingBin = path.resolve(__dirname, '..', '..', 'bin', 'agent-connector.js');
+    if (fs.existsSync(siblingBin)) {
+      mcpFinalArgs = [siblingBin, ...mcpArgs];
+    } else {
+      // Fallback: search installed locations (older layouts, global installs)
+      let oaBin = null;
+      const home3 = os.homedir();
+      const oaExt = IS_WINDOWS ? '.cmd' : '';
+      const runtimesRoot = path.join(home3, '.openagents', 'runtimes');
+      try {
+        for (const d of fs.readdirSync(runtimesRoot, { withFileTypes: true })) {
+          if (d.isDirectory()) {
+            const candidate = path.join(runtimesRoot, d.name, 'node_modules', '.bin', `openagents${oaExt}`);
+            if (fs.existsSync(candidate)) { oaBin = candidate; break; }
+          }
         }
+      } catch {}
+      if (!oaBin) {
+        const oaPortable = path.join(home3, '.openagents', 'nodejs', 'node_modules', '.bin', `openagents${oaExt}`);
+        if (fs.existsSync(oaPortable)) oaBin = oaPortable;
       }
-    } catch {}
-    // Tier 0b: Legacy portable install
-    if (!oaBin) {
-      const oaPortable = path.join(home3, '.openagents', 'nodejs', 'node_modules', '.bin', `openagents${oaExt}`);
-      if (fs.existsSync(oaPortable)) oaBin = oaPortable;
-    }
-    // Tier 1: PATH
-    if (!oaBin) try {
-      if (IS_WINDOWS) {
-        oaBin = execSync('where openagents.cmd 2>nul || where openagents.exe 2>nul || where openagents 2>nul', {
-          encoding: 'utf-8', timeout: 5000,
-        }).split(/\r?\n/)[0].trim();
+      if (!oaBin) try {
+        if (IS_WINDOWS) {
+          oaBin = execSync('where openagents.cmd 2>nul || where openagents.exe 2>nul || where openagents 2>nul', {
+            encoding: 'utf-8', timeout: 5000,
+          }).split(/\r?\n/)[0].trim();
+        } else {
+          oaBin = execSync('which openagents', { encoding: 'utf-8', timeout: 5000 }).trim();
+        }
+      } catch {}
+      if (!oaBin) {
+        this._log('Could not find openagents binary — MCP tools may not be available');
+        mcpCommand = 'openagents';
       } else {
-        oaBin = execSync('which openagents', { encoding: 'utf-8', timeout: 5000 }).trim();
-      }
-    } catch {}
-    // Tier 2: Next to Node.js
-    if (!oaBin) {
-      const nodeBinDir2 = path.dirname(process.execPath);
-      const oaExt = IS_WINDOWS ? '.cmd' : '';
-      const nearNode2 = path.join(nodeBinDir2, `openagents${oaExt}`);
-      if (fs.existsSync(nearNode2)) oaBin = nearNode2;
-    }
-    // Tier 3: Common locations
-    if (!oaBin) {
-      const home2 = os.homedir();
-      const oaCandidates = IS_WINDOWS ? [
-        path.join(process.env.APPDATA || '', 'npm', 'openagents.cmd'),
-      ] : [
-        path.join(home2, '.openagents', 'npm-global', 'bin', 'openagents'),
-        path.join(home2, '.local', 'bin', 'openagents'),
-        path.join(home2, '.npm-global', 'bin', 'openagents'),
-        '/opt/homebrew/bin/openagents',
-        '/usr/local/bin/openagents',
-      ];
-      for (const c of oaCandidates) {
-        if (fs.existsSync(c)) { oaBin = c; break; }
+        const resolved = this._resolveToNodeCmd(oaBin);
+        if (resolved) {
+          mcpCommand = resolved[0];
+          mcpFinalArgs = [resolved[1], ...mcpArgs];
+        } else {
+          mcpCommand = oaBin;
+        }
       }
     }
-    if (!oaBin) {
-      oaBin = 'openagents';
-      this._log('Could not find openagents binary — MCP tools may not be available');
-    }
-
-    // Resolve shim/symlink to node + JS entry point for MCP server
-    // (.cmd shims and #!/usr/bin/env node shebangs both fail as MCP commands)
-    let mcpCommand = oaBin;
-    let mcpFinalArgs = mcpArgs;
-    const mcpResolved = this._resolveToNodeCmd(oaBin);
-    if (mcpResolved) {
-      mcpCommand = mcpResolved[0];
-      mcpFinalArgs = [mcpResolved[1], ...mcpArgs];
-    }
 
     const mcpConfig = {
       mcpServers: {

package/src/adapters/codex.js

@@ -140,7 +140,18 @@ class CodexAdapter extends BaseAdapter {
     const nearNode = path.join(nodeBinDir, `codex${ext}`);
     if (fs.existsSync(nearNode)) return nearNode;
 
-    // Tier 3: Common install locations
+    // Tier 3: npm global prefix (handles custom npm prefix like D:\node\node_global)
+    try {
+      const npmPrefix = execSync('npm config get prefix', {
+        encoding: 'utf-8', timeout: 5000, windowsHide: true,
+      }).trim();
+      if (npmPrefix) {
+        const prefixCandidate = path.join(npmPrefix, `codex${ext}`);
+        if (fs.existsSync(prefixCandidate)) return prefixCandidate;
+      }
+    } catch {}
+
+    // Tier 4: Common install locations
     const candidates = IS_WINDOWS ? [
       path.join(process.env.APPDATA || '', 'npm', 'codex.cmd'),
     ] : [
@@ -265,12 +276,10 @@ class CodexAdapter extends BaseAdapter {
         cmd.push('-C', this.workingDir);
       }
 
-      cmd.push(fullPrompt);
-
       this._log(`Spawning: codex exec ${threadId && attempt === 0 ? `resume ${threadId} ` : ''}--json --full-auto -m ${this._directModel || 'default'}`);
 
       try {
-        const result = await this._spawnCodex(cmd, env, msgChannel);
+        const result = await this._spawnCodex(cmd, env, msgChannel, fullPrompt);
 
         if (result.responseText) {
           await this.sendResponse(msgChannel, result.responseText);
@@ -293,14 +302,15 @@ class CodexAdapter extends BaseAdapter {
     }
   }
 
-  async _spawnCodex(cmd, env, msgChannel) {
+  async _spawnCodex(cmd, env, msgChannel, prompt) {
     return new Promise((resolve, reject) => {
       const proc = spawn(cmd[0], cmd.slice(1), {
-        stdio: ['ignore', 'pipe', 'pipe'],
+        stdio: ['pipe', 'pipe', 'pipe'],
         env,
         cwd: this.workingDir,
         detached: !IS_WINDOWS,
         windowsHide: true,
+        shell: IS_WINDOWS,
       });
       this._channelProcesses[msgChannel] = proc;
 
@@ -314,6 +324,11 @@ class CodexAdapter extends BaseAdapter {
         proc.stderr.on('data', (chunk) => { stderrBuf += chunk.toString('utf-8'); });
       }
 
+      if (proc.stdin) {
+        proc.stdin.write(prompt || '', 'utf-8');
+        proc.stdin.end();
+      }
+
       const processLine = async (line) => {
         line = line.trim();
         if (!line) return;

package/src/cli.js

@@ -459,6 +459,28 @@ async function cmdVersion() {
   print(`${pkg.name} v${pkg.version}`);
 }
 
+async function cmdUpdate() {
+  const { checkForUpdate, runUpdate, currentVersion } = require('./update-check');
+  const info = await checkForUpdate();
+  if (!info) {
+    print('Could not reach the npm registry. Check your network.');
+    process.exitCode = 1;
+    return;
+  }
+  if (!info.isNewer) {
+    print(`Already on the latest version (${currentVersion()}).`);
+    return;
+  }
+  print(`Updating ${info.current} → ${info.latest}...`);
+  const ok = runUpdate();
+  if (!ok) {
+    print('Update failed.');
+    process.exitCode = 1;
+    return;
+  }
+  print(`Updated to ${info.latest}.`);
+}
+
 async function cmdHelp() {
   print(`Usage: agn <command> [options]
 
@@ -485,6 +507,7 @@ Commands:
   workspace join <token>      Join workspace with token
   workspace list              List configured workspaces
   mcp-server                  Start MCP server (stdio) for workspace tools
+  update                      Upgrade launcher to the latest npm release
   version                     Show version
   help                        Show this help
 
@@ -503,6 +526,26 @@ async function main() {
   if (cmd === 'help' || flags.help) { await cmdHelp(); return; }
   if (cmd === 'version' || flags.version) { await cmdVersion(); return; }
 
+  // Check for a newer launcher version and offer to install it. Skip for:
+  //   - mcp-server: JSON-RPC subprocess spawned by Claude Code
+  //   - up --foreground: the backgrounded daemon child
+  //   - tui / auto-TUI: interactive UI manages its own rendering
+  //   - update: already updating; avoid recursion
+  const skipUpdateCheck =
+    cmd === 'mcp-server' ||
+    (cmd === 'up' && flags.foreground) ||
+    cmd === 'tui' ||
+    cmd === 'update' ||
+    flags['no-update-check'] ||
+    process.env.OPENAGENTS_SKIP_UPDATE_CHECK === '1' ||
+    (cmd === 'status' && process.argv.length <= 2 && process.stdin.isTTY);
+  if (!skipUpdateCheck) {
+    try {
+      const { notifyAndMaybeUpdate } = require('./update-check');
+      await notifyAndMaybeUpdate();
+    } catch {}
+  }
+
   const connector = getConnector(flags);
 
   // Launch TUI if command is 'tui' or no command with interactive terminal
@@ -542,6 +585,7 @@ async function main() {
     workspace: () => cmdWorkspace(connector, flags, positional),
     env: () => cmdEnv(connector, flags, positional),
     'test-llm': () => cmdTestLLM(connector, flags, positional),
+    update: () => cmdUpdate(),
     'mcp-server': () => {
       const { runMcpServer } = require('./mcp-server');
       const workspaceId = flags['workspace-id'] || process.env.OPENAGENTS_WORKSPACE_ID;

package/src/installer.js

@@ -5,6 +5,10 @@ const os = require('os');
 const path = require('path');
 const { execSync, exec } = require('child_process');
 const { whichBinary, getEnhancedEnv, getRuntimePrefix } = require('./paths');
+const { EnvManager } = require('./env');
+
+const STATUS_CACHE_TTL_MS = 10000;
+const statusCache = new Map();
 
 /**
  * Manages installation and uninstallation of agent runtimes.
@@ -19,6 +23,7 @@ class Installer {
     this.configDir = configDir;
     this.markersFile = path.join(configDir, 'installed_agents.json');
     this.markersDir = path.join(configDir, 'installed');
+    this.env = new EnvManager(configDir);
   }
 
   /**
@@ -131,7 +136,17 @@ class Installer {
    */
   healthCheck(agentType) {
     const binary = this._whichBinary(agentType);
-    if (!binary) return { installed: false, binary: null, version: null };
+    if (!binary) {
+      return {
+        installed: false,
+        binary: null,
+        version: null,
+        ready: false,
+        auth_mode: null,
+        execution_mode: 'unavailable',
+        message: 'Not installed',
+      };
+    }
 
     const entry = this.registry.getEntry(agentType);
     const checkCmd = entry && entry.install ? entry.install.check_command : null;
@@ -150,51 +165,152 @@ class Installer {
       version = match ? match[1] : raw.split('\n')[0];
     } catch {}
 
-    // Check login/ready status if check_ready is defined
-    let ready = true;
+    const readiness = this._evaluateReadiness(agentType, entry, binary);
+    return { installed: true, binary, version, ...readiness };
+  }
+
+  _evaluateReadiness(agentType, entry, binary) {
     const checkReady = entry?.check_ready;
-    if (checkReady) {
-      ready = false;
-      // Check env vars
-      if (checkReady.env_vars) {
-        for (const v of checkReady.env_vars) {
-          if (process.env[v]) { ready = true; break; }
+    if (!checkReady) {
+      return {
+        ready: true,
+        auth_mode: null,
+        execution_mode: 'unavailable',
+        message: 'Ready',
+      };
+    }
+
+    const savedEnv = this.env.getEffective(agentType, this.registry);
+    const directEnv = this._hasAllValues(process.env, checkReady.env_all);
+    const directSaved = this._hasAllValues(savedEnv, checkReady.saved_env_all || checkReady.env_all);
+    const directReady = directEnv || directSaved;
+    const envAnyReady = this._hasAnyValue(process.env, checkReady.env_vars);
+    const savedAnyReady = !!(checkReady.saved_env_key && savedEnv[checkReady.saved_env_key]);
+    const credsReady = this._checkCredsReady(checkReady);
+
+    let cliReady = false;
+    if (checkReady.status_command && binary) {
+      cliReady = this._checkStatusCommand(checkReady.status_command);
+    }
+
+    if (directReady) {
+      return {
+        ready: true,
+        auth_mode: 'api_key',
+        execution_mode: 'direct',
+        message: 'Ready',
+      };
+    }
+
+    if (cliReady) {
+      return {
+        ready: true,
+        auth_mode: 'cli_login',
+        execution_mode: 'subprocess',
+        message: 'Ready',
+      };
+    }
+
+    if (envAnyReady || savedAnyReady) {
+      // Legacy single-key path (e.g. agents that only advertise env_vars / saved_env_key).
+      // An API key being present means the agent can be launched with it in the environment,
+      // so treat this as a direct-launch configuration.
+      return {
+        ready: true,
+        auth_mode: 'api_key',
+        execution_mode: 'direct',
+        message: 'Ready',
+      };
+    }
+
+    if (credsReady) {
+      return {
+        ready: true,
+        auth_mode: 'cli_login',
+        execution_mode: 'subprocess',
+        message: 'Ready',
+      };
+    }
+
+    return {
+      ready: false,
+      auth_mode: null,
+      execution_mode: 'unavailable',
+      message: checkReady.not_ready_message || 'Not configured',
+    };
+  }
+
+  _hasAllValues(source, keys) {
+    if (!keys || keys.length === 0) return false;
+    return keys.every((key) => !!(source && source[key]));
+  }
+
+  _hasAnyValue(source, keys) {
+    if (!keys || keys.length === 0) return false;
+    return keys.some((key) => !!(source && source[key]));
+  }
+
+  _checkCredsReady(checkReady) {
+    if (checkReady.creds_file) {
+      try {
+        const credsPath = checkReady.creds_file.replace('~', os.homedir());
+        if (fs.existsSync(credsPath)) {
+          const stat = fs.statSync(credsPath);
+          if (stat.isDirectory()) return fs.readdirSync(credsPath).length > 0;
+          const creds = JSON.parse(fs.readFileSync(credsPath, 'utf-8'));
+          if (checkReady.creds_key) return !!creds[checkReady.creds_key];
+          return true;
         }
+      } catch {}
+    }
+
+    if (checkReady.keychain_service && process.platform === 'darwin') {
+      if (this._checkMacKeychain(checkReady.keychain_service, checkReady.creds_key)) {
+        return true;
       }
-      // Check credentials file or directory
-      if (!ready && checkReady.creds_file) {
-        try {
-          const credsPath = checkReady.creds_file.replace('~', os.homedir());
-          if (fs.existsSync(credsPath)) {
-            const stat = fs.statSync(credsPath);
-            if (stat.isDirectory()) {
-              // Directory exists — check if it has files (e.g. session files)
-              ready = fs.readdirSync(credsPath).length > 0;
-            } else {
-              // File — parse JSON and check key
-              const creds = JSON.parse(fs.readFileSync(credsPath, 'utf-8'));
-              if (checkReady.creds_key) {
-                ready = !!creds[checkReady.creds_key];
-              } else {
-                ready = true;
-              }
-            }
-          }
-        } catch {}
-      }
-      // Also check OAuth credentials (Claude Code stores tokens in .credentials.json)
-      if (!ready) {
-        try {
-          const oauthFile = path.join(os.homedir(), '.claude', '.credentials.json');
-          if (fs.existsSync(oauthFile)) {
-            const creds = JSON.parse(fs.readFileSync(oauthFile, 'utf-8'));
-            if (creds.claudeAiOauth?.accessToken) ready = true;
-          }
-        } catch {}
-      }
     }
 
-    return { installed: true, binary, version, ready };
+    return false;
+  }
+
+  /**
+   * Check a macOS Keychain generic-password entry. If creds_key is provided the
+   * stored value is parsed as JSON and required to contain that key; otherwise any
+   * non-empty value counts as ready. Returns false on non-macOS or on any error.
+   */
+  _checkMacKeychain(service, credsKey) {
+    try {
+      const stdout = execSync(
+        `security find-generic-password -s ${JSON.stringify(service)} -w`,
+        { stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000, encoding: 'utf-8' },
+      ).trim();
+      if (!stdout) return false;
+      if (!credsKey) return true;
+      const creds = JSON.parse(stdout);
+      return !!creds[credsKey];
+    } catch {
+      return false;
+    }
+  }
+
+  _checkStatusCommand(command) {
+    const cached = statusCache.get(command);
+    if (cached && (Date.now() - cached.ts) < STATUS_CACHE_TTL_MS) {
+      return cached.ok;
+    }
+
+    let ok = false;
+    try {
+      execSync(command, {
+        stdio: 'ignore',
+        timeout: 5000,
+        env: getEnhancedEnv(),
+      });
+      ok = true;
+    } catch {}
+
+    statusCache.set(command, { ok, ts: Date.now() });
+    return ok;
   }
 
   /**

package/src/paths.js

@@ -139,9 +139,18 @@ function _addWindowsPaths(dirs) {
   // System32 (cmd.exe, powershell, etc) — Electron may not have it
   _push(dirs, path.join(sysRoot, 'System32'));
 
-  // npm global bin
+  // npm global bin (default location)
   if (appData) _push(dirs, path.join(appData, 'npm'));
 
+  // npm global bin (custom prefix — e.g. user configured npm prefix to D:\node\node_global)
+  try {
+    const npmPrefix = execSync('npm config get prefix', {
+      encoding: 'utf-8', timeout: 5000, windowsHide: true,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+    if (npmPrefix) _push(dirs, npmPrefix);
+  } catch {}
+
   // Portable Node.js installed by OpenAgents Launcher
   _push(dirs, path.join(HOME, '.openagents', 'nodejs'));
 

package/src/tui.js

@@ -85,54 +85,11 @@ function loadAgentRows(connector) {
         workspace = agent.network;
       }
     }
-    // Check if agent type needs configuration (API key etc.)
     let notReadyMsg = '';
+    let health = null;
     try {
-      const agentType = agent.type || 'openclaw';
-      const entry = connector.registry.getEntry(agentType);
-      if (entry && entry.check_ready) {
-        const cr = entry.check_ready;
-        let isReady = false;
-        // Check saved env
-        if (cr.saved_env_key) {
-          const saved = connector.env.load(agentType);
-          if (saved[cr.saved_env_key]) isReady = true;
-        }
-        // Check process env vars
-        if (!isReady && cr.env_vars) {
-          for (const v of cr.env_vars) {
-            if (process.env[v]) { isReady = true; break; }
-          }
-        }
-        // Check creds file/directory (for claude)
-        if (!isReady && cr.creds_file) {
-          const credsPath = cr.creds_file.replace('~', process.env.HOME || process.env.USERPROFILE || '');
-          try {
-            if (fs.existsSync(credsPath)) {
-              const stat = fs.statSync(credsPath);
-              if (stat.isDirectory()) {
-                // Directory (e.g. ~/.claude/sessions) — check if it has files
-                isReady = fs.readdirSync(credsPath).length > 0;
-              } else {
-                const creds = JSON.parse(fs.readFileSync(credsPath, 'utf-8'));
-                if (cr.creds_key) isReady = !!creds[cr.creds_key];
-                else isReady = true;
-              }
-            }
-          } catch {}
-        }
-        // Also check OAuth credentials (Claude Code stores tokens in .credentials.json)
-        if (!isReady) {
-          try {
-            const oauthFile = path.join(process.env.HOME || '', '.claude', '.credentials.json');
-            if (fs.existsSync(oauthFile)) {
-              const creds = JSON.parse(fs.readFileSync(oauthFile, 'utf-8'));
-              if (creds.claudeAiOauth && creds.claudeAiOauth.accessToken) isReady = true;
-            }
-          } catch {}
-        }
-        if (!isReady) notReadyMsg = cr.not_ready_message || 'Not configured';
-      }
+      health = connector.healthCheck(agent.type || 'openclaw');
+      if (health && !health.ready) notReadyMsg = health.message || 'Not configured';
     } catch {}
 
     return {
@@ -144,11 +101,24 @@ function loadAgentRows(connector) {
       network: agent.network || '',
       lastError: info.last_error || '',
       notReadyMsg,
+      health,
       configured: true,
     };
   });
 }
 
+function describeHealth(health) {
+  if (!health) return '';
+  if (!health.ready) return health.message || 'Not configured';
+  const parts = ['Ready'];
+  if (health.auth_mode === 'api_key') parts.push('API key');
+  else if (health.auth_mode === 'cli_login') parts.push('CLI login');
+  if (health.execution_mode && health.execution_mode !== 'unavailable') {
+    parts.push(health.execution_mode);
+  }
+  return parts.join(' | ');
+}
+
 function loadCatalog(connector) {
   const { execSync } = require('child_process');
   const entries = connector.registry.getCatalogSync();
@@ -372,6 +342,7 @@ function createTUI() {
         // Detail row: working dir + config warning
         const details = [];
         details.push(r.path || process.env.HOME || '~');
+        if (r.health) details.push(`{cyan-fg}${describeHealth(r.health)}{/cyan-fg}`);
         if (r.notReadyMsg) details.push(`{yellow-fg}⚠ ${r.notReadyMsg}{/yellow-fg}`);
         items.push(`  {gray-fg}  ${details.join('  |  ')}{/gray-fg}`);
       }

package/src/update-check.js

@@ -0,0 +1,203 @@
+'use strict';
+
+/**
+ * Update check + prompt flow.
+ *
+ * Queries the npm registry for the latest @openagents-org/agent-launcher
+ * version and, if newer than the running version, prints a notification
+ * and (for TTY invocations) prompts the user to update in place.
+ */
+
+const https = require('https');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const { execSync, spawnSync } = require('child_process');
+
+const PKG_NAME = '@openagents-org/agent-launcher';
+const CACHE_FILE = path.join(os.homedir(), '.openagents', '.update-check.json');
+const CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+
+function currentVersion() {
+  return require('../package.json').version;
+}
+
+function compareSemver(a, b) {
+  const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0);
+  const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+function loadCache() {
+  try {
+    const data = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'));
+    if (data && data.latest && data.checkedAt &&
+        Date.now() - data.checkedAt < CACHE_TTL_MS) {
+      return data.latest;
+    }
+  } catch {}
+  return null;
+}
+
+function saveCache(latest) {
+  try {
+    fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
+    fs.writeFileSync(CACHE_FILE, JSON.stringify({ latest, checkedAt: Date.now() }));
+  } catch {}
+}
+
+function fetchLatest(timeoutMs = 2500) {
+  return new Promise((resolve) => {
+    const req = https.request(
+      `https://registry.npmjs.org/${PKG_NAME}/latest`,
+      { method: 'GET', timeout: timeoutMs, headers: { Accept: 'application/json' } },
+      (res) => {
+        let body = '';
+        res.on('data', (c) => { body += c; });
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(body);
+            resolve(parsed.version || null);
+          } catch { resolve(null); }
+        });
+      }
+    );
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
+    req.end();
+  });
+}
+
+/**
+ * Return { current, latest, isNewer } or null if the check failed / offline.
+ */
+async function checkForUpdate() {
+  const current = currentVersion();
+  let latest = loadCache();
+  if (!latest) {
+    latest = await fetchLatest();
+    if (latest) saveCache(latest);
+  }
+  if (!latest) return null;
+  return { current, latest, isNewer: compareSemver(latest, current) > 0 };
+}
+
+/**
+ * Walk up from __dirname until we find the enclosing node_modules; the
+ * directory containing node_modules is the install prefix.
+ */
+function detectInstallPrefix() {
+  let dir = __dirname;
+  for (let i = 0; i < 10; i++) {
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    if (path.basename(parent) === 'node_modules') {
+      return path.dirname(parent);
+    }
+    dir = parent;
+  }
+  return null;
+}
+
+function findNpmBin() {
+  const nodeDir = path.dirname(process.execPath);
+  for (const name of ['npm', 'npm.cmd']) {
+    const candidate = path.join(nodeDir, name);
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  try {
+    return execSync(process.platform === 'win32' ? 'where npm' : 'which npm', {
+      encoding: 'utf-8', timeout: 3000,
+    }).trim().split(/\r?\n/)[0];
+  } catch { return 'npm'; }
+}
+
+/**
+ * Run npm install to update to the latest version. Blocking.
+ * Returns true on success.
+ */
+function runUpdate() {
+  const prefix = detectInstallPrefix();
+  const npmBin = findNpmBin();
+  const args = ['install', '--no-save', `${PKG_NAME}@latest`];
+  if (prefix) args.push('--prefix', prefix);
+  else args.push('-g');
+  process.stderr.write(`[launcher] Running: ${npmBin} ${args.join(' ')}\n`);
+  const r = spawnSync(npmBin, args, { stdio: 'inherit' });
+  return r.status === 0;
+}
+
+/**
+ * Prompt for a Y/n keystroke. Defaults to Y on empty input.
+ * Times out after `timeoutMs` and returns false.
+ */
+function promptYes(question, timeoutMs = 30000) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) return resolve(false);
+    process.stderr.write(question);
+    let answered = false;
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    const timer = setTimeout(() => {
+      if (answered) return;
+      answered = true;
+      process.stderr.write('\n');
+      rl.close();
+      resolve(false);
+    }, timeoutMs);
+    rl.question('', (ans) => {
+      if (answered) return;
+      answered = true;
+      clearTimeout(timer);
+      rl.close();
+      const a = (ans || '').trim().toLowerCase();
+      resolve(a === '' || a === 'y' || a === 'yes');
+    });
+  });
+}
+
+/**
+ * Check, notify, and offer to update. Exits the process on successful update.
+ * Safe to call at the top of any user-facing CLI command.
+ */
+async function notifyAndMaybeUpdate() {
+  let info;
+  try { info = await checkForUpdate(); } catch { return; }
+  if (!info || !info.isNewer) return;
+
+  process.stderr.write(
+    `\n[launcher] Update available: ${info.current} → ${info.latest}\n`
+  );
+
+  const interactive = process.stdin.isTTY && process.stdout.isTTY;
+  if (!interactive) {
+    process.stderr.write(
+      '[launcher] Run `agn update` (or re-run install.sh) to upgrade.\n\n'
+    );
+    return;
+  }
+
+  const accepted = await promptYes('[launcher] Update now? [Y/n] ');
+  if (!accepted) {
+    process.stderr.write('[launcher] Skipped. Run `agn update` later to upgrade.\n\n');
+    return;
+  }
+
+  const ok = runUpdate();
+  if (ok) {
+    process.stderr.write(`[launcher] Updated to ${info.latest}. Re-run your command.\n`);
+    process.exit(0);
+  }
+  process.stderr.write('[launcher] Update failed — continuing with current version.\n\n');
+}
+
+module.exports = {
+  checkForUpdate,
+  notifyAndMaybeUpdate,
+  runUpdate,
+  currentVersion,
+};