@openagents-org/agent-connector 0.1.0 → 0.1.2

package/package.json

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

package/src/cli.js

@@ -63,17 +63,17 @@ function table(rows, headers) {
 // ---------------------------------------------------------------------------
 
 async function cmdUp(connector, flags) {
-  const pid = connector.getDaemonPid();
-  if (pid) {
-    print(`Daemon already running (PID ${pid})`);
-    return;
-  }
-
   if (flags.foreground) {
-    // Run in foreground (used by daemonize child)
+    // Run in foreground (used by daemonize child) — skip PID check
+    // because the parent already wrote our PID to the file.
     const daemon = connector.createDaemon();
     await daemon.start();
   } else {
+    const pid = connector.getDaemonPid();
+    if (pid) {
+      print(`Daemon already running (PID ${pid})`);
+      return;
+    }
     // Daemonize
     const foregroundArgs = [process.argv[1], 'up', '--foreground'];
     if (flags.config) foregroundArgs.push('--config', flags.config);

package/src/daemon.js

@@ -2,8 +2,9 @@
 
 const fs = require('fs');
 const path = require('path');
-const { spawn, execSync } = require('child_process');
+const { spawn, execSync, execFileSync } = require('child_process');
 const os = require('os');
+const { WorkspaceClient } = require('./workspace-client');
 
 const IS_WINDOWS = process.platform === 'win32';
 
@@ -145,41 +146,28 @@ class Daemon {
    * The parent process prints info and exits; the child runs `start()`.
    * @param {string[]} foregroundArgs - CLI args for the foreground child process
    */
-  static daemonize(configDir, foregroundArgs) {
+  static daemonize(configDir, foregroundArgs, execPath) {
     const logFile = path.join(configDir, 'daemon.log');
     const pidFile = path.join(configDir, 'daemon.pid');
+    const bin = execPath || process.execPath;
 
     fs.mkdirSync(configDir, { recursive: true });
     const logFd = fs.openSync(logFile, 'a');
 
-    if (IS_WINDOWS) {
-      // Windows: re-launch as detached with CREATE_NO_WINDOW
-      const proc = spawn(process.execPath, foregroundArgs, {
-        detached: true,
-        stdio: ['ignore', logFd, logFd],
-        windowsHide: true,
-        env: { ...process.env },
-      });
-      proc.unref();
-      fs.writeFileSync(pidFile, String(proc.pid), 'utf-8');
-      fs.closeSync(logFd);
-      console.log(`Daemon started (PID ${proc.pid})`);
-      console.log(`Logs: ${logFile}`);
-      console.log('Stop: agent-connector down');
-    } else {
-      // Unix: spawn detached child
-      const proc = spawn(process.execPath, foregroundArgs, {
-        detached: true,
-        stdio: ['ignore', logFd, logFd],
-        env: { ...process.env },
-      });
-      proc.unref();
-      fs.writeFileSync(pidFile, String(proc.pid), 'utf-8');
-      fs.closeSync(logFd);
-      console.log(`Daemon started (PID ${proc.pid})`);
-      console.log(`Logs: ${logFile}`);
-      console.log('Stop: agent-connector down');
-    }
+    const opts = {
+      detached: true,
+      stdio: ['ignore', logFd, logFd],
+      env: { ...process.env },
+    };
+    if (IS_WINDOWS) opts.windowsHide = true;
+
+    const proc = spawn(bin, foregroundArgs, opts);
+    proc.unref();
+    fs.writeFileSync(pidFile, String(proc.pid), 'utf-8');
+    fs.closeSync(logFd);
+    console.log(`Daemon started (PID ${proc.pid})`);
+    console.log(`Logs: ${logFile}`);
+    console.log('Stop: agent-connector down');
   }
 
   /**
@@ -195,7 +183,7 @@ class Daemon {
 
     try {
       if (IS_WINDOWS) {
-        execSync(`taskkill /PID ${pid}`, { stdio: 'ignore', timeout: 5000 });
+        execSync(`taskkill /F /PID ${pid}`, { stdio: 'ignore', timeout: 5000 });
       } else {
         process.kill(pid, 'SIGTERM');
       }
@@ -209,8 +197,8 @@ class Daemon {
         return true;
       }
       // Busy-wait 500ms (sync, used only in CLI stop command)
-      execSync(IS_WINDOWS ? 'timeout /t 1 /nobreak >nul' : 'sleep 0.5', {
-        stdio: 'ignore', timeout: 2000,
+      execSync(IS_WINDOWS ? 'ping -n 2 127.0.0.1 >nul' : 'sleep 0.5', {
+        stdio: 'ignore', timeout: 5000,
       });
     }
 
@@ -257,7 +245,19 @@ class Daemon {
     };
     this._processes[name] = info;
 
-    this._spawnLoop(name, agentCfg, info);
+    // Workspace-connected agents use the adapter loop (poll + CLI per message).
+    // Local-only agents use the spawn loop (long-running child process).
+    const network = agentCfg.network
+      ? this.config.getNetworks().find(
+          (n) => n.slug === agentCfg.network || n.id === agentCfg.network
+        )
+      : null;
+
+    if (network) {
+      this._adapterLoop(name, agentCfg, info, network);
+    } else {
+      this._spawnLoop(name, agentCfg, info);
+    }
   }
 
   async _spawnLoop(name, agentCfg, info) {
@@ -277,6 +277,7 @@ class Daemon {
         info.state = 'starting';
         this._writeStatus();
 
+        this._log(`${name} launching: ${cmd.join(' ')}`);
         const proc = this._spawnAgent(cmd, { env, cwd });
         info.proc = proc;
         info.state = 'running';
@@ -333,6 +334,234 @@ class Daemon {
     this._writeStatus();
   }
 
+  // ---------------------------------------------------------------------------
+  // Internal — adapter loop (workspace-connected agents)
+  // ---------------------------------------------------------------------------
+
+  async _adapterLoop(name, agentCfg, info, network) {
+    const wsClient = new WorkspaceClient(network.endpoint || 'https://workspace-endpoint.openagents.org');
+    const binary = this._resolveAgentBinary(agentCfg);
+    const env = this._buildAgentEnv(agentCfg);
+    let cursor = null;
+    const processedIds = new Set();
+
+    // Skip existing events on startup
+    try {
+      while (true) {
+        const { cursor: newCursor } = await wsClient.pollPending(
+          network.id, name, network.token, { after: cursor, limit: 200 }
+        );
+        if (!newCursor || newCursor === cursor) break;
+        cursor = newCursor;
+      }
+      this._log(`${name} skipped existing events, cursor=${cursor}`);
+    } catch (e) {
+      this._log(`${name} skip-events failed: ${e.message}`);
+    }
+
+    // Heartbeat interval
+    const heartbeatInterval = setInterval(async () => {
+      if (this._stoppedAgents.has(name) || this._shuttingDown) return;
+      try {
+        await wsClient.heartbeat(network.id, name, network.token);
+      } catch (e) {
+        this._log(`${name} heartbeat failed: ${e.message}`);
+      }
+    }, 30000);
+
+    // Send initial heartbeat
+    try { await wsClient.heartbeat(network.id, name, network.token); } catch {}
+
+    info.state = 'running';
+    info.startedAt = new Date().toISOString();
+    this._writeStatus();
+    this._log(`${name} adapter online → ${network.slug}${binary ? ` (binary: ${binary})` : ''}`);
+
+    let idleCount = 0;
+
+    while (!this._shuttingDown && !this._stoppedAgents.has(name)) {
+      try {
+        const { messages, cursor: newCursor } = await wsClient.pollPending(
+          network.id, name, network.token, { after: cursor }
+        );
+        if (newCursor) cursor = newCursor;
+
+        // Filter already-processed messages
+        const incoming = messages.filter((m) => {
+          const id = m.messageId;
+          if (!id || processedIds.has(id)) return false;
+          if (m.messageType === 'status') return false;
+          return true;
+        });
+
+        if (incoming.length > 0) {
+          idleCount = 0;
+          for (const msg of incoming) {
+            if (msg.messageId) processedIds.add(msg.messageId);
+            await this._handleAdapterMessage(name, agentCfg, msg, network, wsClient, binary, env);
+          }
+          // Cap dedup set
+          if (processedIds.size > 2000) {
+            const arr = [...processedIds];
+            processedIds.clear();
+            for (const id of arr.slice(-1000)) processedIds.add(id);
+          }
+        } else {
+          idleCount++;
+        }
+
+        // Adaptive polling: 2s active, up to 15s idle
+        const delay = incoming.length > 0 ? 2000 : Math.min(2000 + idleCount * 1000, 15000);
+        await this._sleep(delay);
+      } catch (e) {
+        if (this._stoppedAgents.has(name) || this._shuttingDown) break;
+        info.lastError = (e.message || String(e)).slice(0, 200);
+        this._log(`${name} poll error: ${info.lastError}`);
+        await this._sleep(5000);
+      }
+    }
+
+    clearInterval(heartbeatInterval);
+
+    // Disconnect from workspace
+    try { await wsClient.disconnect(network.id, name, network.token); } catch {}
+
+    info.state = 'stopped';
+    this._writeStatus();
+    this._log(`${name} adapter stopped`);
+  }
+
+  async _handleAdapterMessage(name, agentCfg, msg, network, wsClient, binary, env) {
+    const content = (msg.content || '').trim();
+    if (!content) return;
+
+    const channel = msg.sessionId || 'general';
+    const sender = msg.senderName || msg.senderType || 'user';
+    this._log(`${name} message from ${sender} in ${channel}: ${content.slice(0, 80)}`);
+
+    // Send "thinking..." status
+    try {
+      await wsClient.sendMessage(network.id, channel, network.token, 'thinking...', {
+        senderType: 'agent', senderName: name, messageType: 'status',
+      });
+    } catch {}
+
+    try {
+      let response;
+      if (binary) {
+        response = await this._runCliAgent(binary, content, channel, agentCfg, network, env);
+      } else {
+        response = `Agent type '${agentCfg.type}' has no CLI binary — cannot process message.`;
+      }
+
+      if (response) {
+        await wsClient.sendMessage(network.id, channel, network.token, response, {
+          senderType: 'agent', senderName: name,
+        });
+        this._log(`${name} responded in ${channel}: ${response.slice(0, 80)}...`);
+      }
+    } catch (e) {
+      const errMsg = `Error: ${(e.message || String(e)).slice(0, 200)}`;
+      this._log(`${name} error handling message: ${errMsg}`);
+      try {
+        await wsClient.sendMessage(network.id, channel, network.token, errMsg, {
+          senderType: 'agent', senderName: name,
+        });
+      } catch {}
+    }
+  }
+
+  _runCliAgent(binary, message, channel, agentCfg, network, env) {
+    return new Promise((resolve, reject) => {
+      const sessionKey = `openagents-${network.id.slice(0, 8)}-${channel.slice(-8)}`;
+      const agentId = agentCfg.openclaw_agent_id || 'main';
+
+      const args = ['agent', '--local', '--agent', agentId,
+        '--session-id', sessionKey, '--message', message, '--json'];
+
+      this._log(`${agentCfg.name} CLI: ${binary} ${args.slice(0, 5).join(' ')} ...`);
+
+      const spawnEnv = { ...env };
+      if (IS_WINDOWS) {
+        const npmBin = path.join(process.env.APPDATA || '', 'npm');
+        if (npmBin && !(spawnEnv.PATH || '').includes(npmBin)) {
+          spawnEnv.PATH = npmBin + ';' + (spawnEnv.PATH || process.env.PATH || '');
+        }
+      }
+
+      // On Windows, .cmd shims need shell:true but that breaks argument
+      // quoting. Use execFileSync-style approach: resolve the .cmd to its
+      // target and run directly, or use spawn without shell and full path.
+      let spawnBinary = binary;
+      let spawnArgs = args;
+      const spawnOpts = {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: spawnEnv,
+        timeout: 600000,
+      };
+
+      if (IS_WINDOWS) {
+        // Find the actual .cmd shim and invoke via cmd.exe /C with proper quoting
+        spawnBinary = process.env.COMSPEC || 'cmd.exe';
+        // Wrap argument containing spaces in double quotes for cmd.exe
+        const quotedArgs = args.map((a) => a.includes(' ') ? `"${a}"` : a);
+        spawnArgs = ['/C', binary, ...quotedArgs];
+      }
+
+      const proc = spawn(spawnBinary, spawnArgs, spawnOpts);
+      let stdout = '';
+      let stderr = '';
+
+      if (proc.stdout) proc.stdout.on('data', (d) => { stdout += d; });
+      if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d; });
+
+      proc.on('error', (err) => reject(err));
+      proc.on('exit', (code) => {
+        if (code !== 0) {
+          reject(new Error(`CLI exited ${code}: ${stderr.slice(0, 300)}`));
+          return;
+        }
+
+        stdout = stdout.trim();
+        if (!stdout) { resolve(''); return; }
+
+        // Parse JSON output — find first '{'
+        const jsonStart = stdout.indexOf('{');
+        if (jsonStart < 0) { resolve(stdout); return; }
+
+        try {
+          const data = JSON.parse(stdout.slice(jsonStart));
+          const payloads = data.payloads || [];
+          if (payloads.length > 0) {
+            const texts = payloads.filter((p) => p.text).map((p) => p.text);
+            resolve(texts.join('\n\n'));
+          } else {
+            resolve(stdout.slice(0, jsonStart).trim() || '');
+          }
+        } catch {
+          resolve(stdout);
+        }
+      });
+    });
+  }
+
+  _resolveAgentBinary(agentCfg) {
+    const entry = this.registry.getEntry(agentCfg.type);
+    let binary = (entry && entry.install && entry.install.binary);
+    if (!binary) {
+      const knownBinaries = {
+        openclaw: 'openclaw', claude: 'claude', codex: 'codex',
+        aider: 'aider', goose: 'goose', gemini: 'gemini',
+      };
+      binary = knownBinaries[agentCfg.type];
+    }
+    return binary || null;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Internal — spawn loop (local-only agents)
+  // ---------------------------------------------------------------------------
+
   _spawnAgent(cmd, opts) {
     const [binary, ...args] = cmd;
     const spawnOpts = {
@@ -341,8 +570,14 @@ class Daemon {
       cwd: opts.cwd,
     };
 
-    if (IS_WINDOWS && binary.toLowerCase().endsWith('.cmd')) {
+    if (IS_WINDOWS) {
+      // On Windows, always use shell so .cmd/.ps1 shims on PATH are found
       spawnOpts.shell = true;
+      // Ensure npm global bin is on PATH
+      const npmBin = path.join(process.env.APPDATA || '', 'npm');
+      if (npmBin && !(process.env.PATH || '').includes(npmBin)) {
+        spawnOpts.env = { ...spawnOpts.env, PATH: npmBin + ';' + (spawnOpts.env.PATH || process.env.PATH || '') };
+      }
     }
 
     const proc = spawn(binary, args, spawnOpts);
@@ -358,19 +593,29 @@ class Daemon {
   }
 
   _getLaunchCommand(agentCfg) {
-    const entry = this.registry.getEntry(agentCfg.type);
-    if (!entry || !entry.install || !entry.install.binary) return null;
+    const binary = this._resolveAgentBinary(agentCfg);
+    if (!binary) return null;
 
-    const binary = entry.install.binary;
+    const entry = this.registry.getEntry(agentCfg.type);
     const args = [];
 
     // Add launch args from registry
-    if (entry.launch && entry.launch.args) {
+    if (entry && entry.launch && entry.launch.args) {
       for (const arg of entry.launch.args) {
         args.push(arg.replace(/\{agent_name\}/g, agentCfg.name));
       }
     }
 
+    // Built-in launch profiles for local-only agents
+    if (!args.length) {
+      const type = agentCfg.type || '';
+      if (type === 'claude') {
+        args.push('--print');
+      } else if (type === 'codex') {
+        args.push('--quiet');
+      }
+    }
+
     return [binary, ...args];
   }
 

package/src/workspace-client.js

@@ -3,7 +3,7 @@
 const https = require('https');
 const http = require('http');
 
-const DEFAULT_ENDPOINT = 'https://endpoint.openagents.org';
+const DEFAULT_ENDPOINT = 'https://workspace-endpoint.openagents.org';
 
 /**
  * HTTP client for workspace API operations.
@@ -143,6 +143,79 @@ class WorkspaceClient {
     }, token);
   }
 
+  /**
+   * Poll for pending messages targeted at an agent via GET /v1/events.
+   * Returns { messages, cursor } where cursor is the last event ID.
+   */
+  async pollPending(workspaceId, agentName, token, { after, limit = 50 } = {}) {
+    const params = new URLSearchParams({
+      network: workspaceId,
+      type: 'workspace.message',
+      limit: String(limit),
+    });
+    if (after) params.set('after', after);
+
+    const data = await this._get(`/v1/events?${params}`, this._wsHeaders(token));
+    const result = data.data || data;
+    const events = (result && result.events) || [];
+
+    let cursor = null;
+    if (events.length > 0) {
+      cursor = events[events.length - 1].id || null;
+    }
+
+    // Filter for messages targeted at this agent
+    const messages = [];
+    for (const e of events) {
+      const source = e.source || '';
+      const meta = e.metadata || {};
+      const targetAgents = meta.target_agents || [];
+
+      // Skip own messages
+      if (source === `openagents:${agentName}`) continue;
+
+      if (source.startsWith('human:')) {
+        // Human messages: pick up if targeted at this agent or broadcast
+        if (!targetAgents.length || targetAgents.includes(agentName)) {
+          messages.push(this._eventToMessage(e));
+        }
+      } else if (source.startsWith('openagents:')) {
+        // Agent messages: only pick up if explicitly mentioned
+        if (targetAgents.includes(agentName)) {
+          messages.push(this._eventToMessage(e));
+        }
+      }
+    }
+
+    return { messages, cursor };
+  }
+
+  /**
+   * Convert an ONM event to a message-compatible object.
+   */
+  _eventToMessage(event) {
+    const source = event.source || '';
+    const isHuman = source.startsWith('human:');
+    const senderName = source.replace('openagents:', '').replace('human:', '');
+    const payload = event.payload || {};
+    const target = event.target || '';
+    const ts = event.timestamp;
+
+    const msg = {
+      messageId: event.id || '',
+      sessionId: target.startsWith('channel/') ? target.replace('channel/', '') : target,
+      senderType: isHuman ? 'human' : 'agent',
+      senderName,
+      content: (payload.content || ''),
+      messageType: payload.message_type || 'chat',
+      metadata: event.metadata || {},
+    };
+    if (ts) {
+      msg.createdAt = new Date(ts).toISOString();
+    }
+    return msg;
+  }
+
   // -- Internal --
 
   _wsHeaders(token) {
@@ -152,6 +225,40 @@ class WorkspaceClient {
     };
   }
 
+  _get(urlPath, headers = {}) {
+    const fullUrl = this.endpoint + urlPath;
+
+    return new Promise((resolve, reject) => {
+      const parsedUrl = new URL(fullUrl);
+      const transport = parsedUrl.protocol === 'https:' ? https : http;
+
+      const req = transport.request(fullUrl, {
+        method: 'GET',
+        headers,
+        timeout: 15000,
+      }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => { data += chunk; });
+        res.on('end', () => {
+          try {
+            const parsed = JSON.parse(data);
+            if (res.statusCode >= 400) {
+              reject(new Error(parsed.message || `HTTP ${res.statusCode}`));
+            } else {
+              resolve(parsed);
+            }
+          } catch {
+            reject(new Error(`Invalid response: ${data.slice(0, 200)}`));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('Request timed out')); });
+      req.end();
+    });
+  }
+
   _post(urlPath, body, headers = {}) {
     if (!headers['Content-Type']) headers['Content-Type'] = 'application/json';
     const jsonBody = JSON.stringify(body);