@openagents-org/agent-connector 0.2.7 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openagents-org/agent-connector",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Agent management CLI and library for OpenAgents — install, configure, and run AI coding agents",
   "main": "src/index.js",
   "bin": {

package/src/autostart.js

@@ -0,0 +1,178 @@
+/**
+ * Autostart — register agent-connector daemon as a system service.
+ *
+ * - macOS: launchd plist
+ * - Linux: systemd user unit
+ * - Windows: Task Scheduler XML
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { whichBinary, IS_WINDOWS } = require('./paths');
+
+const IS_MACOS = process.platform === 'darwin';
+const IS_LINUX = process.platform === 'linux' && !IS_MACOS;
+const HOME = process.env.HOME || process.env.USERPROFILE || '';
+
+const SERVICE_LABEL = 'org.openagents.connector';
+
+/**
+ * Enable autostart on login.
+ */
+function enable(configDir) {
+  const nodeBin = whichBinary('node') || process.execPath;
+  const cliPath = path.resolve(__dirname, '..', 'bin', 'agent-connector.js');
+
+  if (IS_MACOS) return _enableMacOS(nodeBin, cliPath, configDir);
+  if (IS_LINUX) return _enableLinux(nodeBin, cliPath, configDir);
+  if (IS_WINDOWS) return _enableWindows(nodeBin, cliPath, configDir);
+  throw new Error(`Autostart not supported on ${process.platform}`);
+}
+
+/**
+ * Disable autostart.
+ */
+function disable() {
+  if (IS_MACOS) return _disableMacOS();
+  if (IS_LINUX) return _disableLinux();
+  if (IS_WINDOWS) return _disableWindows();
+  throw new Error(`Autostart not supported on ${process.platform}`);
+}
+
+/**
+ * Check if autostart is enabled.
+ */
+function isEnabled() {
+  if (IS_MACOS) {
+    const plistPath = path.join(HOME, 'Library', 'LaunchAgents', `${SERVICE_LABEL}.plist`);
+    return fs.existsSync(plistPath);
+  }
+  if (IS_LINUX) {
+    const unitPath = path.join(HOME, '.config', 'systemd', 'user', 'openagents-connector.service');
+    return fs.existsSync(unitPath);
+  }
+  if (IS_WINDOWS) {
+    try {
+      execSync(`schtasks /Query /TN "OpenAgents Connector"`, { stdio: 'pipe', timeout: 5000 });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+// ---- macOS: launchd ----
+
+function _enableMacOS(nodeBin, cliPath, configDir) {
+  const plistDir = path.join(HOME, 'Library', 'LaunchAgents');
+  fs.mkdirSync(plistDir, { recursive: true });
+
+  const plistPath = path.join(plistDir, `${SERVICE_LABEL}.plist`);
+  const logPath = path.join(configDir, 'daemon.log');
+
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${SERVICE_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodeBin}</string>
+    <string>${cliPath}</string>
+    <string>up</string>
+    <string>--foreground</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${logPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin</string>
+  </dict>
+</dict>
+</plist>`;
+
+  fs.writeFileSync(plistPath, plist, 'utf-8');
+  execSync(`launchctl load -w "${plistPath}"`, { stdio: 'pipe', timeout: 5000 });
+  return { enabled: true, path: plistPath };
+}
+
+function _disableMacOS() {
+  const plistPath = path.join(HOME, 'Library', 'LaunchAgents', `${SERVICE_LABEL}.plist`);
+  try {
+    execSync(`launchctl unload "${plistPath}"`, { stdio: 'pipe', timeout: 5000 });
+  } catch {}
+  try { fs.unlinkSync(plistPath); } catch {}
+  return { enabled: false };
+}
+
+// ---- Linux: systemd user unit ----
+
+function _enableLinux(nodeBin, cliPath, configDir) {
+  const unitDir = path.join(HOME, '.config', 'systemd', 'user');
+  fs.mkdirSync(unitDir, { recursive: true });
+
+  const unitPath = path.join(unitDir, 'openagents-connector.service');
+
+  const unit = `[Unit]
+Description=OpenAgents Connector Daemon
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodeBin} ${cliPath} up --foreground
+Restart=on-failure
+RestartSec=10
+Environment=PATH=/usr/local/bin:/usr/bin:/bin
+
+[Install]
+WantedBy=default.target
+`;
+
+  fs.writeFileSync(unitPath, unit, 'utf-8');
+  execSync('systemctl --user daemon-reload', { stdio: 'pipe', timeout: 5000 });
+  execSync('systemctl --user enable openagents-connector.service', { stdio: 'pipe', timeout: 5000 });
+  execSync('systemctl --user start openagents-connector.service', { stdio: 'pipe', timeout: 5000 });
+  return { enabled: true, path: unitPath };
+}
+
+function _disableLinux() {
+  try {
+    execSync('systemctl --user stop openagents-connector.service', { stdio: 'pipe', timeout: 5000 });
+  } catch {}
+  try {
+    execSync('systemctl --user disable openagents-connector.service', { stdio: 'pipe', timeout: 5000 });
+  } catch {}
+  const unitPath = path.join(HOME, '.config', 'systemd', 'user', 'openagents-connector.service');
+  try { fs.unlinkSync(unitPath); } catch {}
+  return { enabled: false };
+}
+
+// ---- Windows: Task Scheduler ----
+
+function _enableWindows(nodeBin, cliPath, configDir) {
+  const taskName = 'OpenAgents Connector';
+  const cmd = `schtasks /Create /SC ONLOGON /TN "${taskName}" /TR "\\"${nodeBin}\\" \\"${cliPath}\\" up --foreground" /RL HIGHEST /F`;
+  execSync(cmd, { stdio: 'pipe', timeout: 10000 });
+  return { enabled: true, method: 'Task Scheduler' };
+}
+
+function _disableWindows() {
+  try {
+    execSync('schtasks /Delete /TN "OpenAgents Connector" /F', { stdio: 'pipe', timeout: 5000 });
+  } catch {}
+  return { enabled: false };
+}
+
+module.exports = { enable, disable, isEnabled };

package/src/cli.js

@@ -327,6 +327,17 @@ async function cmdLogs(connector, flags, positional) {
   }
 }
 
+async function cmdAutostart(connector, flags) {
+  const autostart = require('./autostart');
+  if (flags.disable) {
+    autostart.disable();
+    print('Autostart disabled.');
+  } else {
+    const result = autostart.enable(connector._config ? connector._config.configDir : require('path').join(require('os').homedir(), '.openagents'));
+    print(`Autostart enabled.${result.path ? ` Config: ${result.path}` : ''}`);
+  }
+}
+
 async function cmdWorkspace(connector, flags, positional) {
   const sub = positional[0] || 'list';
   const subArgs = positional.slice(1);
@@ -461,6 +472,7 @@ Commands:
   connect <agent> <token>     Connect agent to workspace
   disconnect <agent>          Disconnect agent from workspace
   env <type> [--set K=V]      View/set env vars for agent type
+  autostart [--disable]       Enable/disable auto-start on login
   test-llm <type>             Test LLM connection
   logs [agent] [--lines N]    View daemon logs
   workspace create [name]     Create a new workspace
@@ -502,6 +514,7 @@ async function main() {
     connect: () => cmdConnect(connector, flags, positional),
     disconnect: () => cmdDisconnect(connector, flags, positional),
     logs: () => cmdLogs(connector, flags, positional),
+    autostart: () => cmdAutostart(connector, flags),
     workspace: () => cmdWorkspace(connector, flags, positional),
     env: () => cmdEnv(connector, flags, positional),
     'test-llm': () => cmdTestLLM(connector, flags, positional),

package/src/installer.js

@@ -94,6 +94,60 @@ class Installer {
     return { success: true, output };
   }
 
+  /**
+   * Install with streaming output via callback.
+   * @param {string} agentType
+   * @param {function(string)} onData - called with each chunk of output
+   * @returns {Promise<{success: boolean, command: string}>}
+   */
+  async installStreaming(agentType, onData) {
+    const { spawn } = require('child_process');
+    const entry = this.registry.getEntry(agentType);
+    if (!entry || !entry.install) {
+      throw new Error(`No install definition for agent type: ${agentType}`);
+    }
+
+    let cmd = this._getInstallCommand(entry.install);
+    if (!cmd) {
+      throw new Error(`No install command for ${agentType} on ${Installer.platform()}`);
+    }
+
+    // Add verbose logging for npm so user sees download progress on stderr
+    if (cmd.includes('npm install') && !cmd.includes('--loglevel')) {
+      cmd = cmd.replace('npm install', 'npm install --loglevel=verbose');
+    }
+
+    if (onData) onData(`$ ${cmd}\n\n`);
+
+    const env = this._buildShellEnv();
+    const shell = process.platform === 'win32'
+      ? (process.env.ComSpec || 'C:\\Windows\\System32\\cmd.exe')
+      : true;
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(cmd, [], { shell, env, stdio: ['ignore', 'pipe', 'pipe'] });
+
+      if (proc.stdout) proc.stdout.setEncoding('utf-8');
+      if (proc.stderr) proc.stderr.setEncoding('utf-8');
+
+      if (proc.stdout) proc.stdout.on('data', (d) => { if (onData) onData(d); });
+      if (proc.stderr) proc.stderr.on('data', (d) => { if (onData) onData(d); });
+
+      proc.on('error', (err) => reject(err));
+      proc.on('close', (code) => {
+        if (code === 0) {
+          this._markInstalled(agentType);
+          if (onData) onData(`\nDone! ${agentType} is now installed.\n`);
+          resolve({ success: true, command: cmd });
+        } else {
+          const msg = `Install failed with exit code ${code}`;
+          if (onData) onData(`\n${msg}\n`);
+          reject(new Error(msg));
+        }
+      });
+    });
+  }
+
   /**
    * Uninstall an agent runtime.
    * @returns {Promise<{success: boolean, output: string}>}
@@ -115,6 +169,58 @@ class Installer {
     return { success: true, output };
   }
 
+  /**
+   * Uninstall with streaming output via callback.
+   */
+  async uninstallStreaming(agentType, onData) {
+    const { spawn } = require('child_process');
+    const entry = this.registry.getEntry(agentType);
+    if (!entry || !entry.install) {
+      throw new Error(`No install definition for agent type: ${agentType}`);
+    }
+
+    const installCmd = this._getInstallCommand(entry.install);
+    let cmd = this._deriveUninstallCommand(installCmd);
+    if (!cmd) {
+      throw new Error(`Cannot derive uninstall command for ${agentType}`);
+    }
+
+    // Add verbose logging for npm so user sees progress on stderr
+    if (cmd.includes('npm uninstall') && !cmd.includes('--loglevel')) {
+      cmd = cmd.replace('npm uninstall', 'npm uninstall --loglevel=verbose');
+    }
+
+    if (onData) onData(`$ ${cmd}\n\n`);
+
+    const env = this._buildShellEnv();
+    const shell = process.platform === 'win32'
+      ? (process.env.ComSpec || 'C:\\Windows\\System32\\cmd.exe')
+      : true;
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(cmd, [], { shell, env, stdio: ['ignore', 'pipe', 'pipe'] });
+
+      if (proc.stdout) proc.stdout.setEncoding('utf-8');
+      if (proc.stderr) proc.stderr.setEncoding('utf-8');
+
+      if (proc.stdout) proc.stdout.on('data', (d) => { if (onData) onData(d); });
+      if (proc.stderr) proc.stderr.on('data', (d) => { if (onData) onData(d); });
+
+      proc.on('error', (err) => reject(err));
+      proc.on('close', (code) => {
+        if (code === 0) {
+          this._markUninstalled(agentType);
+          if (onData) onData(`\nDone! ${agentType} has been uninstalled.\n`);
+          resolve({ success: true, command: cmd });
+        } else {
+          const msg = `Uninstall failed with exit code ${code}`;
+          if (onData) onData(`\n${msg}\n`);
+          reject(new Error(msg));
+        }
+      });
+    });
+  }
+
   /**
    * Get install command for current platform.
    */
@@ -223,25 +329,43 @@ class Installer {
     } catch {}
   }
 
-  // -- Shell exec --
+  // -- Shell env + exec --
+
+  _buildShellEnv() {
+    const env = { ...process.env };
+    const sep = process.platform === 'win32' ? ';' : ':';
+    const extraDirs = [];
+    try { extraDirs.push(path.dirname(process.execPath)); } catch {}
+    if (process.platform === 'win32') {
+      const appData = env.APPDATA || '';
+      if (appData) extraDirs.push(path.join(appData, 'npm'));
+      extraDirs.push(env.ProgramFiles ? path.join(env.ProgramFiles, 'nodejs') : 'C:\\Program Files\\nodejs');
+      extraDirs.push(env.SystemRoot ? path.join(env.SystemRoot, 'System32') : 'C:\\Windows\\System32');
+      extraDirs.push(env.ProgramFiles ? path.join(env.ProgramFiles, 'Git', 'cmd') : 'C:\\Program Files\\Git\\cmd');
+    } else {
+      extraDirs.push('/usr/local/bin', '/opt/homebrew/bin');
+    }
+    for (const d of extraDirs) {
+      if (d && !(env.PATH || '').includes(d)) {
+        env.PATH = d + sep + (env.PATH || '');
+      }
+    }
+    return env;
+  }
 
   _execShell(cmd, timeoutMs = 300000) {
     return new Promise((resolve, reject) => {
-      const env = getEnhancedEnv();
-      // Also include Electron's own binary dir
-      const execDir = path.dirname(process.execPath);
-      if (execDir && !(env.PATH || '').includes(execDir)) {
-        const sep = process.platform === 'win32' ? ';' : ':';
-        env.PATH = execDir + sep + (env.PATH || '');
-      }
+      const env = this._buildShellEnv();
 
-      // On Windows, force UTF-8 codepage to avoid GBK garbled output
-      const shellCmd = process.platform === 'win32' ? `chcp 65001 >nul && ${cmd}` : cmd;
+      let shell = true;
+      if (process.platform === 'win32') {
+        shell = env.ComSpec || 'C:\\Windows\\System32\\cmd.exe';
+      }
 
-      exec(shellCmd, {
+      exec(cmd, {
         encoding: 'utf-8',
         timeout: timeoutMs,
-        shell: true,
+        shell,
         env,
       }, (error, stdout, stderr) => {
         const output = ((stdout || '') + '\n' + (stderr || '')).trim();

package/src/paths.js

@@ -36,11 +36,19 @@ function getExtraBinDirs() {
   // Common: ~/.local/bin (pipx, user installs)
   _push(dirs, path.join(HOME, '.local', 'bin'));
 
+  // Also add the directory containing the current node binary
+  try {
+    const nodeDir = path.dirname(process.execPath);
+    if (nodeDir) _push(dirs, nodeDir);
+  } catch {}
+
   // Filter to existing directories only, deduplicate
   const seen = new Set();
   const currentPATH = process.env.PATH || '';
   return dirs.filter(d => {
-    if (!d || seen.has(d) || currentPATH.includes(d)) return false;
+    if (!d || seen.has(d)) return false;
+    // Skip if already in PATH (case-insensitive on Windows)
+    if (IS_WINDOWS ? currentPATH.toLowerCase().includes(d.toLowerCase()) : currentPATH.includes(d)) return false;
     seen.add(d);
     try {
       return fs.statSync(d).isDirectory();
@@ -71,10 +79,14 @@ function getEnhancedEnv(baseEnv) {
   }
   if (IS_WINDOWS) {
     // Force UTF-8 output from child processes on non-English Windows locales
-    // (prevents GBK/Shift-JIS garbled text in error messages)
     env.PYTHONIOENCODING = env.PYTHONIOENCODING || 'utf-8';
     env.PYTHONUTF8 = env.PYTHONUTF8 || '1';
     env.LANG = env.LANG || 'en_US.UTF-8';
+    // Ensure ComSpec points to cmd.exe (Electron may not set it)
+    if (!env.ComSpec) {
+      const sysRoot = env.SystemRoot || 'C:\\Windows';
+      env.ComSpec = path.join(sysRoot, 'System32', 'cmd.exe');
+    }
   }
   return env;
 }
@@ -104,6 +116,10 @@ function _addWindowsPaths(dirs) {
   const appData = process.env.APPDATA || '';
   const localAppData = process.env.LOCALAPPDATA || '';
   const programFiles = process.env.ProgramFiles || 'C:\\Program Files';
+  const sysRoot = process.env.SystemRoot || 'C:\\Windows';
+
+  // System32 (cmd.exe, powershell, etc) — Electron may not have it
+  _push(dirs, path.join(sysRoot, 'System32'));
 
   // npm global bin
   if (appData) _push(dirs, path.join(appData, 'npm'));