@openagents-org/agent-launcher 0.1.16 → 0.2.1

package/src/adapters/opencode.js

@@ -0,0 +1,380 @@
+/**
+ * OpenCode adapter for OpenAgents workspace.
+ *
+ * Bridges OpenCode (opencode-ai) to an OpenAgents workspace by running
+ * `opencode run --format json` as a subprocess. OpenCode handles its own
+ * model configuration, provider selection, and tool chain.
+ *
+ * Port of Python PR #316: src/openagents/adapters/opencode.py
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync, spawn } = require('child_process');
+
+const BaseAdapter = require('./base');
+const { formatAttachmentsForPrompt } = require('./utils');
+const { buildOpenCodeSkillMd, buildOpenCodeSystemPrompt } = require('./workspace-prompt');
+
+const IS_WINDOWS = process.platform === 'win32';
+
+class OpenCodeAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts - BaseAdapter opts plus:
+   * @param {Set} [opts.disabledModules]
+   * @param {string} [opts.workingDir]
+   */
+  constructor(opts) {
+    super(opts);
+    this.disabledModules = opts.disabledModules || new Set();
+    this.workingDir = opts.workingDir || undefined;
+
+    // Agent home directory: ~/.openagents/agents/{agentName}/
+    this.agentHome = path.join(os.homedir(), '.openagents', 'agents', this.agentName);
+    fs.mkdirSync(this.agentHome, { recursive: true });
+
+    this._channelSessions = {};
+    this._sessionsFile = path.join(this.agentHome, 'sessions.json');
+    this._migrateSessionsFile();
+    this._loadSessions();
+
+    this._opencodeBinary = this._findOpencodeBinary();
+    if (this._opencodeBinary) {
+      this._log(`Using OpenCode subprocess mode: ${this._opencodeBinary}`);
+    } else {
+      this._log('OpenCode binary not found. Install with: npm install -g opencode-ai@latest');
+    }
+  }
+
+  /**
+   * Migrate sessions file from old location to agent home.
+   */
+  _migrateSessionsFile() {
+    const oldPath = path.join(
+      os.homedir(), '.openagents', 'sessions',
+      `${this.workspaceId}_${this.agentName}_opencode.json`
+    );
+    try {
+      if (fs.existsSync(oldPath) && !fs.existsSync(this._sessionsFile)) {
+        fs.copyFileSync(oldPath, this._sessionsFile);
+        fs.unlinkSync(oldPath);
+        this._log(`Migrated sessions file from ${oldPath}`);
+      }
+    } catch {}
+  }
+
+  _loadSessions() {
+    try {
+      if (fs.existsSync(this._sessionsFile)) {
+        const data = JSON.parse(fs.readFileSync(this._sessionsFile, 'utf-8'));
+        if (data && typeof data === 'object') {
+          Object.assign(this._channelSessions, data);
+          this._log(`Loaded ${Object.keys(data).length} session(s)`);
+        }
+      }
+    } catch {
+      this._log('Could not load sessions file, starting fresh');
+    }
+  }
+
+  _saveSessions() {
+    try {
+      fs.mkdirSync(path.dirname(this._sessionsFile), { recursive: true });
+      fs.writeFileSync(this._sessionsFile, JSON.stringify(this._channelSessions));
+    } catch {}
+  }
+
+  /**
+   * Write workspace skill to OpenCode's skill directory for auto-discovery.
+   */
+  _ensureWorkspaceSkill(channelName) {
+    const skillDir = path.join(this.agentHome, '.opencode', 'skills');
+    const skillFile = path.join(skillDir, 'openagents-workspace.md');
+    try {
+      const content = buildOpenCodeSkillMd({
+        endpoint: this.endpoint,
+        workspaceId: this.workspaceId,
+        token: this.token,
+        agentName: this.agentName,
+        channelName,
+        disabledModules: this.disabledModules,
+      });
+      fs.mkdirSync(skillDir, { recursive: true });
+      fs.writeFileSync(skillFile, content, 'utf-8');
+    } catch {}
+  }
+
+  _buildSystemContext(channelName) {
+    return buildOpenCodeSystemPrompt({
+      agentName: this.agentName,
+      workspaceId: this.workspaceId,
+      channelName,
+      endpoint: this.endpoint,
+      token: this.token,
+      mode: this._mode,
+      disabledModules: this.disabledModules,
+    });
+  }
+
+  // ------------------------------------------------------------------
+  // Binary discovery
+  // ------------------------------------------------------------------
+
+  _findOpencodeBinary() {
+    // Tier 1: PATH
+    try {
+      if (IS_WINDOWS) {
+        const r = execSync('where opencode.cmd 2>nul || where opencode.exe 2>nul || where opencode 2>nul', {
+          encoding: 'utf-8', timeout: 5000,
+        });
+        return r.split(/\r?\n/)[0].trim();
+      } else {
+        return execSync('which opencode', { encoding: 'utf-8', timeout: 5000 }).trim();
+      }
+    } catch {}
+
+    // Tier 2: Next to Node.js
+    const ext = IS_WINDOWS ? '.cmd' : '';
+    const nearNode = path.join(path.dirname(process.execPath), `opencode${ext}`);
+    if (fs.existsSync(nearNode)) return nearNode;
+
+    // Tier 3: Common locations
+    const home = os.homedir();
+    const candidates = IS_WINDOWS ? [
+      path.join(process.env.APPDATA || '', 'npm', 'opencode.cmd'),
+    ] : [
+      path.join(home, '.openagents', 'npm-global', 'bin', 'opencode'),
+      path.join(home, '.npm-global', 'bin', 'opencode'),
+      path.join(home, '.local', 'bin', 'opencode'),
+      '/usr/local/bin/opencode',
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c)) return c;
+    }
+    return null;
+  }
+
+  // ------------------------------------------------------------------
+  // Message handler
+  // ------------------------------------------------------------------
+
+  async _handleMessage(msg) {
+    let content = (msg.content || '').trim();
+    const attachments = msg.attachments || [];
+
+    const attText = formatAttachmentsForPrompt(attachments);
+    if (attText) {
+      content = content ? content + attText : attText.trim();
+    }
+
+    if (!content) return;
+
+    const msgChannel = msg.sessionId || this.channelName;
+    const sender = msg.senderName || msg.senderType || 'user';
+    this._log(`Processing message from ${sender} in ${msgChannel}: ${content.slice(0, 80)}...`);
+
+    await this._autoTitleChannel(msgChannel, content);
+    await this.sendStatus(msgChannel, 'thinking...');
+
+    try {
+      const responseText = await this._runOpencode(content, msgChannel);
+
+      if (responseText) {
+        await this.sendResponse(msgChannel, responseText);
+      } else {
+        await this.sendResponse(msgChannel, 'No response generated. Please try again.');
+      }
+    } catch (e) {
+      this._log(`Error handling message: ${e.message}`);
+      await this.sendError(msgChannel, `Error processing message: ${e.message}`);
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // JSON output parsing
+  // ------------------------------------------------------------------
+
+  /**
+   * Split a string containing concatenated JSON objects.
+   */
+  static _splitJsonObjects(raw) {
+    const objects = [];
+    raw = raw.trim();
+    let pos = 0;
+    while (pos < raw.length) {
+      if (' \t\r\n'.includes(raw[pos])) { pos++; continue; }
+      if (raw[pos] !== '{') { pos++; continue; }
+      // Find matching brace
+      let depth = 0;
+      let inStr = false;
+      let escape = false;
+      let start = pos;
+      for (let i = pos; i < raw.length; i++) {
+        const ch = raw[i];
+        if (escape) { escape = false; continue; }
+        if (ch === '\\' && inStr) { escape = true; continue; }
+        if (ch === '"') { inStr = !inStr; continue; }
+        if (inStr) continue;
+        if (ch === '{') depth++;
+        else if (ch === '}') {
+          depth--;
+          if (depth === 0) {
+            try {
+              const obj = JSON.parse(raw.slice(start, i + 1));
+              if (typeof obj === 'object' && obj !== null) objects.push(obj);
+            } catch {}
+            pos = i + 1;
+            break;
+          }
+        }
+        if (i === raw.length - 1) pos = raw.length; // no match, skip
+      }
+      if (depth !== 0) break; // unbalanced, stop
+    }
+    return objects;
+  }
+
+  /**
+   * Extract user-visible text from a single opencode JSON event.
+   */
+  static _extractTextFromEvent(event) {
+    const eventType = event.type || '';
+    if (['step_start', 'step_finish', 'tool_use'].includes(eventType)) return null;
+
+    const part = event.part;
+    if (part && typeof part === 'object') {
+      const text = part.text || part.content || '';
+      if (text) return text;
+    }
+
+    const item = event.item || event;
+    const text = item.text || item.content || '';
+    return text || null;
+  }
+
+  /**
+   * Extract human-readable text from opencode --format json output.
+   */
+  static _extractTextFromJson(raw) {
+    const events = OpenCodeAdapter._splitJsonObjects(raw);
+    if (!events.length) return raw.trim();
+
+    const texts = [];
+    for (const event of events) {
+      const text = OpenCodeAdapter._extractTextFromEvent(event);
+      if (text) texts.push(text);
+    }
+    return texts.length ? texts.join('\n').trim() : raw.trim();
+  }
+
+  /**
+   * Extract and persist session_id from OpenCode JSON events.
+   */
+  _persistSessionId(channel, rawOutput) {
+    const events = OpenCodeAdapter._splitJsonObjects(rawOutput);
+    let sessionId = null;
+    for (const event of events) {
+      let sid = event.sessionID;
+      if (!sid && event.session && typeof event.session === 'object') {
+        sid = event.session.id;
+      }
+      if (!sid && event.part && typeof event.part === 'object') {
+        sid = event.part.sessionID;
+      }
+      if (sid && typeof sid === 'string') sessionId = sid;
+    }
+
+    if (sessionId) {
+      const prev = this._channelSessions[channel];
+      this._channelSessions[channel] = sessionId;
+      this._saveSessions();
+      if (prev !== sessionId) {
+        this._log(`OpenCode session for channel ${channel}: ${sessionId}`);
+      }
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // Subprocess execution
+  // ------------------------------------------------------------------
+
+  _runOpencode(content, msgChannel) {
+    const binary = this._opencodeBinary || this._findOpencodeBinary();
+    if (binary) this._opencodeBinary = binary;
+    if (!binary) {
+      return Promise.reject(new Error(
+        'opencode CLI not found. Install with: npm install -g opencode-ai@latest'
+      ));
+    }
+
+    const cmd = [binary, 'run', '--format', 'json', '--dir', this.agentHome];
+
+    const sessionId = this._channelSessions[msgChannel];
+    let fullPrompt;
+    if (sessionId) {
+      fullPrompt = content;
+      cmd.push('--session', sessionId);
+    } else {
+      this._ensureWorkspaceSkill(msgChannel);
+      const context = this._buildSystemContext(msgChannel);
+      fullPrompt = `${context}\n\n---\n\n${content}`;
+    }
+
+    this._log(`CLI: ${binary} ${cmd.slice(1, 5).join(' ')} ...`);
+
+    const spawnEnv = { ...(this.agentEnv || process.env) };
+
+    let spawnBinary = cmd[0];
+    let spawnArgs = cmd.slice(1);
+    if (IS_WINDOWS && spawnBinary.toLowerCase().endsWith('.cmd')) {
+      spawnArgs = ['/C', spawnBinary, ...spawnArgs];
+      spawnBinary = process.env.COMSPEC || 'cmd.exe';
+    }
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(spawnBinary, spawnArgs, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: spawnEnv,
+        cwd: this.agentHome,
+        timeout: 300000, // 5 minutes
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      if (proc.stdout) proc.stdout.on('data', (d) => { stdout += d; });
+      if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d; });
+
+      // Send the prompt via stdin
+      if (proc.stdin) {
+        proc.stdin.write(fullPrompt, 'utf-8');
+        proc.stdin.end();
+      }
+
+      proc.on('error', (err) => reject(err));
+      proc.on('exit', (code) => {
+        stdout = stdout.trim();
+        stderr = stderr.trim();
+
+        if (code !== 0) {
+          this._log(`opencode exited with code ${code}: ${stderr.slice(0, 300)}`);
+        }
+
+        if (stdout) {
+          this._persistSessionId(msgChannel, stdout);
+          resolve(OpenCodeAdapter._extractTextFromJson(stdout));
+        } else {
+          if (stderr) {
+            this._log(`opencode stderr: ${stderr.slice(0, 300)}`);
+          }
+          resolve('');
+        }
+      });
+    });
+  }
+}
+
+module.exports = OpenCodeAdapter;

package/src/adapters/workspace-prompt.js

@@ -282,6 +282,41 @@ function buildOpenclawSkillMd({ endpoint, workspaceId, token, agentName, channel
   return frontmatter + identity + '\n' + collab + '\n' + body;
 }
 
+/**
+ * Build system prompt for OpenCode adapter.
+ */
+function buildOpenCodeSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules }) {
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, mode);
+  const collab = buildCollaborationPrompt();
+  const modePrompt = buildModePrompt(mode);
+  const api = buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channelName, disabledModules, mode });
+  return identity + '\n' + collab + '\n' + modePrompt + '\n' + api;
+}
+
+/**
+ * Build workspace skill markdown for OpenCode (written to .opencode/skills/).
+ */
+function buildOpenCodeSkillMd({ endpoint, workspaceId, token, agentName, channelName, disabledModules }) {
+  const api = buildApiSkillsPrompt({
+    endpoint, workspaceId, token, agentName,
+    channelName: channelName || 'general',
+    disabledModules,
+    mode: 'execute',
+  });
+
+  const frontmatter =
+    '---\n' +
+    'name: openagents-workspace\n' +
+    'description: OpenAgents Workspace API — shared files, browser, and agent collaboration\n' +
+    '---\n\n';
+
+  const identity =
+    `You are agent '${agentName}' connected to OpenAgents workspace ${workspaceId}.\n` +
+    'Use these APIs via bash + curl to interact with the workspace.\n\n';
+
+  return frontmatter + identity + api;
+}
+
 module.exports = {
   buildWorkspaceIdentity,
   buildCollaborationPrompt,
@@ -290,4 +325,6 @@ module.exports = {
   buildClaudeSystemPrompt,
   buildOpenclawSystemPrompt,
   buildOpenclawSkillMd,
+  buildOpenCodeSystemPrompt,
+  buildOpenCodeSkillMd,
 };

package/src/daemon.js

@@ -67,6 +67,8 @@ class Daemon {
 
     this._writeStatus();
     this._cachedAgentNames = new Set(agents.map(a => a.name));
+    this._cachedAgentConfigs = {};
+    for (const a of agents) this._cachedAgentConfigs[a.name] = a.network || '';
     this._log(`Daemon started with ${agents.length} agent(s)`);
 
     // Block until shutdown
@@ -158,17 +160,31 @@ class Daemon {
     fs.mkdirSync(configDir, { recursive: true });
     const logFd = fs.openSync(logFile, 'a');
 
+    // Build env with enhanced PATH (ensures node/npm are findable)
+    const env = getEnhancedEnv();
+    // Ensure the directory containing the node binary is on PATH
+    const nodeBinDir = path.dirname(bin);
+    if (env.PATH && !env.PATH.includes(nodeBinDir)) {
+      env.PATH = nodeBinDir + path.delimiter + env.PATH;
+    }
+
     const opts = {
       detached: true,
       stdio: ['ignore', logFd, logFd],
-      env: getEnhancedEnv(),
+      env,
+      cwd: configDir,
     };
     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);
+
+    // Give child a moment to start before closing the log fd
+    setTimeout(() => {
+      try { fs.closeSync(logFd); } catch {}
+    }, 1000);
+
     console.log(`Daemon started (PID ${proc.pid})`);
     console.log(`Logs: ${logFile}`);
     console.log('Stop: agent-connector down');
@@ -260,10 +276,10 @@ class Daemon {
     if (network) {
       this._adapterLoop(name, agentCfg, info, network);
     } else {
-      // No workspace connected — nothing to do, mark as idle
-      info.state = 'stopped';
+      // No workspace connected — agent is ready but not connected
+      info.state = 'idle';
       this._writeStatus();
-      this._log(`${name} idle (no workspace connected)`);
+      this._log(`${name} ready (no workspace connected)`);
     }
   }
 
@@ -358,6 +374,7 @@ class Daemon {
         token: network.token,
         agentName: name,
         endpoint,
+        agentType,
         openclawAgentId: agentCfg.openclaw_agent_id || 'main',
         disabledModules: new Set(),
         agentEnv: this._buildAgentEnv(agentCfg),
@@ -577,9 +594,12 @@ class Daemon {
   _reload() {
     this._log('Reloading config...');
     const oldNames = this._cachedAgentNames || new Set();
+    const oldConfigs = this._cachedAgentConfigs || {};
     // Re-read config from disk
     const newAgents = this.config.getAgents();
     const newNames = new Set(newAgents.map(a => a.name));
+    const newConfigs = {};
+    for (const a of newAgents) newConfigs[a.name] = a.network || '';
 
     // Stop removed agents
     for (const name of oldNames) {
@@ -589,15 +609,21 @@ class Daemon {
       }
     }
 
-    // Start new agents
+    // Start new agents or restart agents whose network changed
     for (const agent of newAgents) {
       if (!oldNames.has(agent.name)) {
         this._launchAgent(agent);
         this._log(`Reload: started new agent '${agent.name}'`);
+      } else if ((oldConfigs[agent.name] || '') !== (agent.network || '')) {
+        // Network config changed — restart agent
+        this.stopAgent(agent.name);
+        this._launchAgent(agent);
+        this._log(`Reload: restarted '${agent.name}' (network changed)`);
       }
     }
 
     this._cachedAgentNames = newNames;
+    this._cachedAgentConfigs = newConfigs;
     this._writeStatus();
   }
 

package/src/identity.js

@@ -0,0 +1,113 @@
+'use strict';
+
+/**
+ * Local identity management (~/.openagents/identity.json).
+ *
+ * Port of Python: src/openagents/client/workspace_client.py (identity section)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const IDENTITY_DIR = path.join(os.homedir(), '.openagents');
+const IDENTITY_FILE = path.join(IDENTITY_DIR, 'identity.json');
+
+function _loadIdentities() {
+  try {
+    if (fs.existsSync(IDENTITY_FILE)) {
+      return JSON.parse(fs.readFileSync(IDENTITY_FILE, 'utf-8'));
+    }
+  } catch {}
+  return { agents: {}, user_email: null };
+}
+
+function _saveIdentities(data) {
+  try {
+    fs.mkdirSync(IDENTITY_DIR, { recursive: true });
+    fs.writeFileSync(IDENTITY_FILE, JSON.stringify(data, null, 2));
+    // Restrict permissions (best-effort)
+    try { fs.chmodSync(IDENTITY_FILE, 0o600); } catch {}
+  } catch {}
+}
+
+/**
+ * Get the saved identity for an agent type.
+ * @returns {{ agentName, agentType, apiKey, createdAt } | null}
+ */
+function getIdentity(agentType) {
+  const data = _loadIdentities();
+  const entry = (data.agents || {})[agentType];
+  if (entry) {
+    return {
+      agentName: entry.agent_name,
+      agentType,
+      apiKey: entry.api_key || null,
+      createdAt: entry.created_at || null,
+    };
+  }
+  return null;
+}
+
+/**
+ * Save an agent identity to local storage.
+ */
+function saveIdentity({ agentName, agentType, apiKey, createdAt }) {
+  const data = _loadIdentities();
+  if (!data.agents) data.agents = {};
+  data.agents[agentType] = {
+    agent_name: agentName,
+    api_key: apiKey || null,
+    created_at: createdAt || new Date().toISOString(),
+  };
+  _saveIdentities(data);
+}
+
+/**
+ * Get the logged-in user email.
+ */
+function getUserEmail() {
+  return _loadIdentities().user_email || null;
+}
+
+/**
+ * Set the logged-in user email.
+ */
+function setUserEmail(email) {
+  const data = _loadIdentities();
+  data.user_email = email;
+  _saveIdentities(data);
+}
+
+/**
+ * Clear the logged-in user email (logout).
+ */
+function clearUserEmail() {
+  const data = _loadIdentities();
+  data.user_email = null;
+  _saveIdentities(data);
+}
+
+/**
+ * Generate an auto-name: {type}-{context}-{4hex} or {type}-{4hex}.
+ */
+function generateAgentName(agentType, context) {
+  const suffix = crypto.randomBytes(2).toString('hex');
+  if (context) {
+    const ctx = context.toLowerCase().replace(/\s+/g, '-').slice(0, 20);
+    return `${agentType}-${ctx}-${suffix}`;
+  }
+  return `${agentType}-${suffix}`;
+}
+
+module.exports = {
+  getIdentity,
+  saveIdentity,
+  getUserEmail,
+  setUserEmail,
+  clearUserEmail,
+  generateAgentName,
+  IDENTITY_DIR,
+  IDENTITY_FILE,
+};

package/src/index.js

@@ -139,6 +139,11 @@ class AgentConnector {
    * Start daemon in background (daemonize).
    */
   startDaemon(foregroundArgs) {
+    if (!foregroundArgs) {
+      // Auto-detect the CLI entry point for foreground mode
+      const binPath = require.resolve('../bin/agent-connector.js');
+      foregroundArgs = [binPath, 'up', '--foreground'];
+    }
     Daemon.daemonize(this._configDir, foregroundArgs);
   }