@openagents-org/agent-launcher 0.2.102 → 0.2.109

package/package.json

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

package/src/adapters/base.js

@@ -12,12 +12,12 @@
  *
  * Subclasses must implement _handleMessage(msg).
  *
- * Direct port of Python: src/openagents/adapters/base.py
+ * Direct port of Python: sdk/src/openagents/adapters/base.py
  */
 
 'use strict';
 
-const { WorkspaceClient } = require('../workspace-client');
+const { WorkspaceClient, SessionRevokedError } = require('../workspace-client');
 const { generateSessionTitle, SESSION_DEFAULT_RE } = require('./utils');
 
 const DEFAULT_ENDPOINT = 'https://workspace-endpoint.openagents.org';
@@ -43,6 +43,7 @@ class BaseAdapter {
     this.client = new WorkspaceClient(this.endpoint);
     this._lastEventId = null;
     this._running = false;
+    this._sessionId = null;  // issued by server on /v1/join; used to prove liveness
     this._processedIds = new Set();
     this._titledSessions = new Set();
     this._mode = 'execute';
@@ -65,13 +66,14 @@ class BaseAdapter {
 
     // Announce agent to workspace
     try {
-      await this.client.joinNetwork(this.agentName, this.token, {
+      const joinResult = await this.client.joinNetwork(this.agentName, this.token, {
         network: this.workspaceId,
         agentType: this.agentType || 'agent',
         serverHost: require('os').hostname(),
         workingDir: this.workingDir || process.cwd(),
       });
-      this._log(`Joined workspace ${this.workspaceId}`);
+      this._sessionId = (joinResult && joinResult.session_id) || null;
+      this._log(`Joined workspace ${this.workspaceId}${this._sessionId ? ` (session ${this._sessionId.slice(0, 8)})` : ''}`);
     } catch (e) {
       this._log(`Warning: join failed: ${e.message}`);
     }
@@ -130,8 +132,13 @@ class BaseAdapter {
 
   async _heartbeat() {
     try {
-      await this.client.heartbeat(this.workspaceId, this.agentName, this.token);
+      await this.client.heartbeat(this.workspaceId, this.agentName, this.token, this._sessionId);
     } catch (e) {
+      if (e instanceof SessionRevokedError) {
+        this._log(`SESSION REVOKED: another client joined as '${this.agentName}'. Stopping adapter.`);
+        this._running = false;
+        return;
+      }
       this._log(`Heartbeat failed: ${e.message}`);
     }
   }
@@ -312,8 +319,11 @@ class BaseAdapter {
         senderName: this.agentName,
         messageType: 'status',
         metadata: { agent_mode: this._mode },
+        sessionId: this._sessionId,
       });
-    } catch {}
+    } catch (e) {
+      if (e instanceof SessionRevokedError) this._onSessionRevoked();
+    }
   }
 
   async sendThinking(channel, content) {
@@ -323,15 +333,27 @@ class BaseAdapter {
         senderName: this.agentName,
         messageType: 'thinking',
         metadata: { agent_mode: this._mode },
+        sessionId: this._sessionId,
       });
-    } catch {}
+    } catch (e) {
+      if (e instanceof SessionRevokedError) this._onSessionRevoked();
+    }
   }
 
   async sendResponse(channel, content) {
-    await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
-      senderType: 'agent',
-      senderName: this.agentName,
-    });
+    try {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+        senderType: 'agent',
+        senderName: this.agentName,
+        sessionId: this._sessionId,
+      });
+    } catch (e) {
+      if (e instanceof SessionRevokedError) {
+        this._onSessionRevoked();
+        return;
+      }
+      throw e;
+    }
   }
 
   async sendError(channel, error) {
@@ -339,8 +361,16 @@ class BaseAdapter {
       await this.client.sendMessage(this.workspaceId, channel, this.token, error, {
         senderType: 'agent',
         senderName: this.agentName,
+        sessionId: this._sessionId,
       });
-    } catch {}
+    } catch (e) {
+      if (e instanceof SessionRevokedError) this._onSessionRevoked();
+    }
+  }
+
+  _onSessionRevoked() {
+    this._log(`SESSION REVOKED: another client joined as '${this.agentName}'. Stopping adapter.`);
+    this._running = false;
   }
 
   // ------------------------------------------------------------------

package/src/adapters/claude.js

@@ -6,7 +6,7 @@
  * - Claude CLI subprocess (stream-json) for task execution
  * - MCP server for workspace tool access
  *
- * Direct port of Python: src/openagents/adapters/claude.py
+ * Direct port of Python: sdk/src/openagents/adapters/claude.py
  */
 
 'use strict';

package/src/adapters/codex.js

@@ -48,15 +48,31 @@ class CodexAdapter extends BaseAdapter {
     );
     this._loadSessions();
 
-    // Determine mode: CLI binary preferred, direct API as fallback
+    // Determine mode:
+    // - CLI mode: only works with OpenAI's native Responses API (api.openai.com)
+    // - Direct API mode: works with any OpenAI-compatible chat completions endpoint
     this._codexBin = this._findCodexBinary();
     this._directMode = false;
+    this._useCliMode = false;
 
-    if (this._codexBin) {
+    // Check if base URL is OpenAI's native API (CLI requires Responses API)
+    const isOpenAiNative = !this._directBaseUrl ||
+      this._directBaseUrl.includes('api.openai.com');
+
+    if (this._codexBin && isOpenAiNative) {
+      this._useCliMode = true;
       this._log(`CLI mode: ${this._codexBin}`);
     } else if (this._directApiKey && this._directBaseUrl) {
       this._directMode = true;
-      this._log(`Direct LLM mode (CLI not found): ${this._directBaseUrl} model=${this._directModel || 'gpt-4o'}`);
+      if (this._codexBin) {
+        this._log(`Direct LLM mode (non-OpenAI endpoint, CLI requires Responses API): ${this._directBaseUrl} model=${this._directModel || 'gpt-4o'}`);
+      } else {
+        this._log(`Direct LLM mode: ${this._directBaseUrl} model=${this._directModel || 'gpt-4o'}`);
+      }
+    } else if (this._codexBin) {
+      // CLI binary found, no custom base URL — assume OpenAI
+      this._useCliMode = true;
+      this._log(`CLI mode: ${this._codexBin}`);
     } else {
       this._log('Warning: No codex CLI binary found and no direct API configured');
     }
@@ -203,7 +219,7 @@ class CodexAdapter extends BaseAdapter {
     await this._autoTitleChannel(msgChannel, content);
     await this.sendStatus(msgChannel, 'thinking...');
 
-    if (this._codexBin) {
+    if (this._useCliMode) {
       await this._handleViaSubprocess(content, msgChannel);
     } else if (this._directMode) {
       await this._handleViaDirectApi(content, msgChannel);

package/src/adapters/cursor.js

@@ -2,7 +2,7 @@
  * Cursor adapter — AI-powered code editor agent mode.
  *
  * Uses direct LLM API mode (OpenAI-compatible chat completions).
- * Port of Python: src/openagents/adapters/cursor.py
+ * Port of Python: sdk/src/openagents/adapters/cursor.py
  */
 
 'use strict';

package/src/adapters/llm-direct.js

@@ -4,7 +4,7 @@
  * Calls OpenAI-compatible chat completions API directly with SSE streaming.
  * No CLI binary needed — just OPENAI_API_KEY + OPENAI_BASE_URL.
  *
- * Port of Python: src/openagents/adapters/nanoclaw.py & cursor.py
+ * Port of Python: sdk/src/openagents/adapters/nanoclaw.py & cursor.py
  */
 
 'use strict';

package/src/adapters/nanoclaw.js

@@ -2,7 +2,7 @@
  * NanoClaw adapter — lightweight containerized coding agent.
  *
  * Uses direct LLM API mode (OpenAI-compatible chat completions).
- * Port of Python: src/openagents/adapters/nanoclaw.py
+ * Port of Python: sdk/src/openagents/adapters/nanoclaw.py
  */
 
 'use strict';

package/src/adapters/openclaw.js

@@ -5,7 +5,7 @@
  * - CLI mode: `openclaw agent --local --json` (preferred)
  * - Workspace context injected via SKILL.md auto-discovery
  *
- * Direct port of Python: src/openagents/adapters/openclaw.py
+ * Direct port of Python: sdk/src/openagents/adapters/openclaw.py
  * (CLI mode only — gateway WS and direct HTTP modes are not yet ported)
  */
 

package/src/adapters/opencode.js

@@ -5,7 +5,7 @@
  * `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
+ * Port of Python PR #316: sdk/src/openagents/adapters/opencode.py
  */
 
 'use strict';

package/src/adapters/utils.js

@@ -1,7 +1,7 @@
 /**
  * Shared utilities for adapter implementations.
  *
- * Direct port of Python: src/openagents/adapters/utils.py
+ * Direct port of Python: sdk/src/openagents/adapters/utils.py
  */
 
 'use strict';

package/src/adapters/workspace-prompt.js

@@ -6,7 +6,7 @@
  * - Multi-agent collaboration (@mention delegation)
  * - Workspace REST API skills (files, browser, tunnels)
  *
- * Direct port of Python: src/openagents/adapters/workspace_prompt.py
+ * Direct port of Python: sdk/src/openagents/adapters/workspace_prompt.py
  */
 
 'use strict';
@@ -21,8 +21,12 @@ function buildWorkspaceIdentity(agentName, workspaceId, channelName, mode = 'exe
     '— just write your answer naturally.\n\n' +
     '## Workspace Context\n' +
     `- Workspace ID: ${workspaceId}\n` +
-    `- Channel: ${channelName}\n` +
-    `- Mode: ${mode}\n`
+    `- Channel: ${channelName}  (this is the channel you are currently speaking in)\n` +
+    `- Mode: ${mode}\n\n` +
+    'When you need prior context, call `workspace_get_history` with ' +
+    `\`channel="${channelName}"\` (the current channel). Without the ` +
+    'channel argument the tool falls back to a default channel that may ' +
+    'be different from where you are.\n'
   );
 }
 

package/src/daemon.js

@@ -30,6 +30,7 @@ class Daemon {
     this._shuttingDown = false;
     this._statusInterval = null;
     this._cmdInterval = null;
+    this._reloadInFlight = null;  // serialize concurrent _reload() calls
   }
 
   // ---------------------------------------------------------------------------
@@ -182,6 +183,22 @@ class Daemon {
     const bin = execPath || process.execPath;
 
     fs.mkdirSync(configDir, { recursive: true });
+
+    // Refuse to start if an existing daemon is already running.
+    // Without this check, repeated `agn up` invocations would spawn
+    // multiple daemons that each process the same message → duplicate
+    // bot replies.
+    const existingPid = Daemon._readPid(pidFile);
+    if (existingPid && Daemon._isAlive(existingPid)) {
+      console.error(`Daemon already running (PID ${existingPid}).`);
+      console.error(`Run 'agn down' first, or 'agn status' to check.`);
+      process.exit(1);
+    }
+    // Stale pid file — clean up before spawning fresh
+    if (existingPid) {
+      try { fs.unlinkSync(pidFile); } catch {}
+    }
+
     const logFd = fs.openSync(logFile, 'a');
 
     // Build env with enhanced PATH (ensures node/npm are findable)
@@ -636,6 +653,27 @@ class Daemon {
   }
 
   async _reload() {
+    // Serialize reloads. fs.watch, the 'reload' command, and SIGHUP can
+    // all fire concurrently. Without a mutex, two _reload() calls in flight
+    // may both observe the same stale `this._adapters[name]` entry between
+    // stopAgent() and _launchAgent(), leaving a ghost adapter running
+    // alongside the new one → duplicate bot replies per message.
+    if (this._reloadInFlight) {
+      // Wait for the in-flight reload to finish, then run once more
+      // (the config may have changed again since it started).
+      this._reloadInFlight = this._reloadInFlight.then(
+        () => this._reloadUnsafe(),
+        () => this._reloadUnsafe(),
+      );
+      return this._reloadInFlight;
+    }
+    this._reloadInFlight = this._reloadUnsafe().finally(() => {
+      this._reloadInFlight = null;
+    });
+    return this._reloadInFlight;
+  }
+
+  async _reloadUnsafe() {
     this._log('Reloading config...');
     const oldNames = this._cachedAgentNames || new Set();
     const oldConfigs = this._cachedAgentConfigs || {};
@@ -657,12 +695,14 @@ class Daemon {
     // Start new agents or restart agents whose network changed
     for (const agent of newAgents) {
       if (!oldNames.has(agent.name)) {
+        await this._ensureAdapterCleared(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
         await this.stopAgent(agent.name);
         this._stoppedAgents.delete(agent.name);
+        await this._ensureAdapterCleared(agent.name);
         this._launchAgent(agent);
         this._log(`Reload: restarted '${agent.name}' (network changed)`);
       }
@@ -673,6 +713,28 @@ class Daemon {
     this._writeStatus();
   }
 
+  /**
+   * Wait until the old adapter (if any) has fully released its slot in
+   * this._adapters before relaunching. stopAgent already waits up to 5s,
+   * but on slow shutdowns that can be too short — and _launchAgent's
+   * duplicate-check would then silently skip the relaunch, leaving the
+   * OLD adapter running instead of starting the new one.
+   */
+  async _ensureAdapterCleared(name) {
+    for (let i = 0; i < 20; i++) {
+      if (!this._adapters || !this._adapters[name]) return;
+      await this._sleep(500);
+    }
+    // Last resort: force-clear the slot so the new adapter can start.
+    // The old adapter will exit on its next poll iteration since its
+    // entry in _stoppedAgents triggers adapter.stop() via checkStop.
+    if (this._adapters && this._adapters[name]) {
+      this._log(`WARNING: adapter '${name}' did not clear after 10s — force-releasing slot to avoid duplicate`);
+      try { this._adapters[name].stop(); } catch {}
+      delete this._adapters[name];
+    }
+  }
+
   _writePid() {
     try {
       fs.writeFileSync(this.config.pidFile, String(process.pid), 'utf-8');

package/src/identity.js

@@ -3,7 +3,7 @@
 /**
  * Local identity management (~/.openagents/identity.json).
  *
- * Port of Python: src/openagents/client/workspace_client.py (identity section)
+ * Port of Python: sdk/src/openagents/client/workspace_client.py (identity section)
  */
 
 const fs = require('fs');

package/src/mcp-server.js

@@ -27,11 +27,12 @@ function buildToolDefs(disabledModules) {
     // -- Workspace core (always enabled) --
     {
       name: 'workspace_get_history',
-      description: 'Read recent messages in the current workspace channel.',
+      description: 'Read recent messages in a workspace channel. Defaults to the current channel; pass channel to query another.',
       inputSchema: {
         type: 'object',
         properties: {
           limit: { type: 'integer', description: 'Number of messages to return (default 20)', default: 20 },
+          channel: { type: 'string', description: 'Channel name (e.g. "channel-9bcd8e66"); omit to use the current channel.' },
         },
       },
     },
@@ -341,7 +342,8 @@ class McpServer {
 
       case 'workspace_get_history': {
         const limit = args.limit || 20;
-        const data = await this.ws.pollMessages(this.workspaceId, this.channelName, this.token, { limit });
+        const channel = args.channel || this.channelName;
+        const data = await this.ws.pollMessages(this.workspaceId, channel, this.token, { limit });
         const events = data.events || data || [];
         if (!events.length) return text('No messages yet.');
         const lines = events.map((e) => {

package/src/workspace-client.js

@@ -5,6 +5,19 @@ const http = require('http');
 
 const DEFAULT_ENDPOINT = 'https://workspace-endpoint.openagents.org';
 
+/**
+ * Thrown when the workspace rejects a request because our session_id has
+ * been revoked by a newer /v1/join as the same agent. Callers should
+ * stop the adapter rather than retry.
+ */
+class SessionRevokedError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'SessionRevokedError';
+    this.code = 'session_revoked';
+  }
+}
+
 /**
  * HTTP client for workspace API operations.
  *
@@ -84,12 +97,18 @@ class WorkspaceClient {
 
   /**
    * Send heartbeat via POST /v1/heartbeat.
+   *
+   * @param {string} [sessionId] - optional session id returned by /v1/join.
+   *   If the server's current session for this agent differs, _post()
+   *   throws SessionRevokedError and the caller should stop its adapter.
    */
-  async heartbeat(workspaceId, agentName, token) {
-    const data = await this._post('/v1/heartbeat', {
+  async heartbeat(workspaceId, agentName, token, sessionId) {
+    const body = {
       agent_name: agentName,
       network: workspaceId,
-    }, this._wsHeaders(token));
+    };
+    if (sessionId) body.session_id = sessionId;
+    const data = await this._post('/v1/heartbeat', body, this._wsHeaders(token));
     return data.data || data;
   }
 
@@ -107,9 +126,15 @@ class WorkspaceClient {
 
   /**
    * Post a raw event via POST /v1/events.
+   *
+   * @param {string} [sessionId] - if given, embedded in event.metadata so
+   *   the server can reject stale sessions with SessionRevokedError.
    */
-  async sendEvent(workspaceId, event, token) {
+  async sendEvent(workspaceId, event, token, sessionId) {
     event.network = workspaceId;
+    if (sessionId) {
+      event.metadata = { ...(event.metadata || {}), session_id: sessionId };
+    }
     const data = await this._post('/v1/events', event, this._wsHeaders(token));
     return data.data || data;
   }
@@ -118,7 +143,7 @@ class WorkspaceClient {
    * Send a chat message to a workspace channel.
    */
   async sendMessage(workspaceId, channelName, token, content, {
-    senderType = 'agent', senderName, messageType = 'chat', metadata, attachments,
+    senderType = 'agent', senderName, messageType = 'chat', metadata, attachments, sessionId,
   } = {}) {
     const sourcePrefix = senderType === 'agent' ? 'openagents' : 'human';
     const source = senderName ? `${sourcePrefix}:${senderName}` : `${sourcePrefix}:unknown`;
@@ -132,7 +157,7 @@ class WorkspaceClient {
       target: `channel/${channelName}`,
       payload,
       metadata: metadata || {},
-    }, token);
+    }, token, sessionId);
   }
 
   /**
@@ -175,24 +200,41 @@ class WorkspaceClient {
       cursor = events[events.length - 1].id || null;
     }
 
-    // Filter for messages targeted at this agent
+    // Filter for messages targeted at this agent.
+    //
+    // target_agents semantics:
+    //   • absent            → legacy server with no routing decision
+    //                         (broadcast for human messages, ignore for agents)
+    //   • [...agentNames]   → only listed agents should respond
+    //   • ["__no_response__"]
+    //                       → routing happened and decided nobody
+    //                         should respond. Sentinel is used instead
+    //                         of [] because pre-0.2.106 clients treat
+    //                         empty array as "broadcast" and every
+    //                         agent would reply. The sentinel is
+    //                         non-empty and matches no real agent.
     const messages = [];
     for (const e of events) {
       const source = e.source || '';
       const meta = e.metadata || {};
-      const targetAgents = meta.target_agents || [];
+      const targetAgents = meta.target_agents;
+      const hasTargetList = Array.isArray(targetAgents);
 
       // 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)) {
+        if (hasTargetList) {
+          if (targetAgents.includes(agentName)) {
+            messages.push(this._eventToMessage(e));
+          }
+        } else {
+          // Legacy server (no target_agents): broadcast for compat
           messages.push(this._eventToMessage(e));
         }
       } else if (source.startsWith('openagents:')) {
-        // Agent messages: only pick up if explicitly mentioned
-        if (targetAgents.includes(agentName)) {
+        // Agent messages: only pick up if explicitly listed
+        if (hasTargetList && targetAgents.includes(agentName)) {
           messages.push(this._eventToMessage(e));
         }
       }
@@ -545,7 +587,11 @@ class WorkspaceClient {
             const parsed = JSON.parse(data);
             if (res.statusCode >= 400) {
               const msg = parsed.message || `HTTP ${res.statusCode}`;
-              reject(new Error(msg));
+              if (typeof msg === 'string' && msg.toLowerCase().includes('session_revoked')) {
+                reject(new SessionRevokedError(msg));
+              } else {
+                reject(new Error(msg));
+              }
             } else {
               resolve(parsed);
             }
@@ -634,4 +680,4 @@ class WorkspaceClient {
   }
 }
 
-module.exports = { WorkspaceClient };
+module.exports = { WorkspaceClient, SessionRevokedError };