@openagents-org/agent-connector 0.1.11 → 0.2.1

package/package.json

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

package/src/adapters/base.js

@@ -0,0 +1,327 @@
+/**
+ * Base adapter for OpenAgents workspace.
+ *
+ * Extracts the common connectivity logic shared by all adapters:
+ * - Event cursor management and skip-existing-events on startup
+ * - Heartbeat loop (30s)
+ * - Adaptive poll loop with deduplication
+ * - Control event polling (mode changes, stop)
+ * - Per-channel task dispatch with queuing
+ * - Auto-titling of new channels
+ * - Graceful shutdown with disconnect
+ *
+ * Subclasses must implement _handleMessage(msg).
+ *
+ * Direct port of Python: src/openagents/adapters/base.py
+ */
+
+'use strict';
+
+const { WorkspaceClient } = require('../workspace-client');
+const { generateSessionTitle, SESSION_DEFAULT_RE } = require('./utils');
+
+const DEFAULT_ENDPOINT = 'https://workspace-endpoint.openagents.org';
+
+class BaseAdapter {
+  /**
+   * @param {object} opts
+   * @param {string} opts.workspaceId
+   * @param {string} opts.channelName - default/initial channel
+   * @param {string} opts.token
+   * @param {string} opts.agentName
+   * @param {string} [opts.endpoint]
+   */
+  constructor({ workspaceId, channelName, token, agentName, endpoint }) {
+    this.workspaceId = workspaceId;
+    this.channelName = channelName;
+    this.token = token;
+    this.agentName = agentName;
+    this.endpoint = endpoint || DEFAULT_ENDPOINT;
+    this.client = new WorkspaceClient(this.endpoint);
+    this._lastEventId = null;
+    this._running = false;
+    this._processedIds = new Set();
+    this._titledSessions = new Set();
+    this._mode = 'execute';
+    this._lastControlId = null;
+    // Per-channel task tracking for parallel execution
+    this._channelBusy = new Set();
+    this._channelQueues = {};
+    this._log = (msg) => {
+      const ts = new Date().toISOString();
+      console.log(`${ts} INFO adapter: ${msg}`);
+    };
+  }
+
+  // ------------------------------------------------------------------
+  // Lifecycle
+  // ------------------------------------------------------------------
+
+  async run() {
+    this._running = true;
+    await this._skipExistingEvents();
+
+    const heartbeatInterval = setInterval(() => this._heartbeat(), 30000);
+    const controlInterval = setInterval(() => this._pollControl(), 2000);
+
+    try {
+      // Send initial heartbeat
+      await this._heartbeat();
+      await this._pollLoop();
+    } finally {
+      this._running = false;
+      clearInterval(heartbeatInterval);
+      clearInterval(controlInterval);
+      try {
+        await this.client.disconnect(this.workspaceId, this.agentName, this.token);
+      } catch {}
+    }
+  }
+
+  stop() {
+    this._running = false;
+  }
+
+  // ------------------------------------------------------------------
+  // Event cursor / skip existing
+  // ------------------------------------------------------------------
+
+  async _skipExistingEvents() {
+    try {
+      while (true) {
+        const { cursor } = await this.client.pollPending(
+          this.workspaceId, this.agentName, this.token,
+          { after: this._lastEventId, limit: 200 }
+        );
+        if (!cursor || cursor === this._lastEventId) break;
+        this._lastEventId = cursor;
+      }
+      if (this._lastEventId) {
+        this._log(`Skipped existing events, cursor at ${this._lastEventId}`);
+      }
+    } catch (e) {
+      this._log(`Failed to skip existing events: ${e.message}`);
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // Heartbeat
+  // ------------------------------------------------------------------
+
+  async _heartbeat() {
+    try {
+      await this.client.heartbeat(this.workspaceId, this.agentName, this.token);
+    } catch (e) {
+      this._log(`Heartbeat failed: ${e.message}`);
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // Control polling
+  // ------------------------------------------------------------------
+
+  async _pollControl() {
+    try {
+      const events = await this.client.pollControl(
+        this.workspaceId, this.agentName, this.token,
+        { after: this._lastControlId }
+      );
+      for (const ev of events) {
+        if (ev.id) this._lastControlId = ev.id;
+        const payload = ev.payload || {};
+        const action = payload.action;
+        if (action === 'set_mode') {
+          const newMode = payload.mode || 'execute';
+          if ((newMode === 'execute' || newMode === 'plan') && newMode !== this._mode) {
+            const oldMode = this._mode;
+            this._mode = newMode;
+            this._log(`Mode changed: ${oldMode} -> ${newMode}`);
+          }
+        } else {
+          await this._onControlAction(action, payload);
+        }
+      }
+    } catch {}
+  }
+
+  /**
+   * Handle adapter-specific control actions. Override in subclasses.
+   */
+  async _onControlAction(_action, _payload) {}
+
+  // ------------------------------------------------------------------
+  // Poll loop
+  // ------------------------------------------------------------------
+
+  async _pollLoop() {
+    let idleCount = 0;
+
+    while (this._running) {
+      let messages, rawCursor;
+      try {
+        const result = await this.client.pollPending(
+          this.workspaceId, this.agentName, this.token,
+          { after: this._lastEventId }
+        );
+        messages = result.messages;
+        rawCursor = result.cursor;
+      } catch (e) {
+        this._log(`Poll failed: ${e.message}`);
+        await this._sleep(5000);
+        continue;
+      }
+
+      if (rawCursor) this._lastEventId = rawCursor;
+
+      // Deduplicate
+      const incoming = [];
+      for (const msg of messages) {
+        const msgId = msg.id || msg.messageId;
+        if (msgId && this._processedIds.has(msgId)) continue;
+        if (msg.messageType === 'status') continue;
+        incoming.push(msg);
+      }
+
+      if (incoming.length > 0) {
+        idleCount = 0;
+        for (const msg of incoming) {
+          const msgId = msg.id || msg.messageId;
+          if (msgId) this._processedIds.add(msgId);
+          await this._dispatchMessage(msg);
+        }
+        // Cap dedup set
+        if (this._processedIds.size > 2000) {
+          const arr = [...this._processedIds];
+          this._processedIds.clear();
+          for (const id of arr.slice(-1000)) this._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);
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // Channel dispatch
+  // ------------------------------------------------------------------
+
+  async _dispatchMessage(msg) {
+    const channel = msg.sessionId || this.channelName;
+
+    if (this._channelBusy.has(channel)) {
+      if (!this._channelQueues[channel]) this._channelQueues[channel] = [];
+      this._channelQueues[channel].push(msg);
+      try {
+        await this.sendStatus(channel, 'message queued — will process after current task');
+      } catch {}
+      return;
+    }
+
+    // Run channel worker (don't await — parallel execution)
+    this._channelWorker(channel, msg);
+  }
+
+  async _channelWorker(channel, msg) {
+    this._channelBusy.add(channel);
+    try {
+      await this._handleMessage(msg);
+    } catch (e) {
+      this._log(`Error in channel worker for ${channel}: ${e.message}`);
+      try { await this.sendError(channel, `Agent error: ${e.message}`); } catch {}
+    }
+
+    // Drain queue
+    while (true) {
+      const queue = this._channelQueues[channel];
+      if (!queue || queue.length === 0) break;
+      const nextMsg = queue.shift();
+      try {
+        await this._handleMessage(nextMsg);
+      } catch (e) {
+        this._log(`Error processing queued message in ${channel}: ${e.message}`);
+        try { await this.sendError(channel, `Agent error: ${e.message}`); } catch {}
+      }
+    }
+    this._channelBusy.delete(channel);
+  }
+
+  // ------------------------------------------------------------------
+  // Auto-title helper
+  // ------------------------------------------------------------------
+
+  async _autoTitleChannel(channel, content) {
+    if (this._titledSessions.has(channel)) return;
+    this._titledSessions.add(channel);
+    const title = generateSessionTitle(content);
+    if (!title) return;
+    try {
+      const info = await this.client.getSession(this.workspaceId, channel, this.token);
+      if (!info.titleManuallySet && SESSION_DEFAULT_RE.test(info.title || '')) {
+        await this.client.updateSession(
+          this.workspaceId, channel, this.token,
+          { title, autoTitle: true }
+        );
+        this._log(`Auto-titled channel: ${title}`);
+      }
+    } catch (e) {
+      this._log(`Failed to auto-title channel: ${e.message}`);
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // Message helpers
+  // ------------------------------------------------------------------
+
+  async sendStatus(channel, content) {
+    try {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+        senderType: 'agent',
+        senderName: this.agentName,
+        messageType: 'status',
+        metadata: { agent_mode: this._mode },
+      });
+    } catch {}
+  }
+
+  async sendResponse(channel, content) {
+    await this.client.sendMessage(this.workspaceId, channel, this.token, content, {
+      senderType: 'agent',
+      senderName: this.agentName,
+    });
+  }
+
+  async sendError(channel, error) {
+    try {
+      await this.client.sendMessage(this.workspaceId, channel, this.token, error, {
+        senderType: 'agent',
+        senderName: this.agentName,
+      });
+    } catch {}
+  }
+
+  // ------------------------------------------------------------------
+  // Abstract
+  // ------------------------------------------------------------------
+
+  /**
+   * Process a single incoming message. Must be implemented by subclasses.
+   * @param {object} msg
+   */
+  async _handleMessage(_msg) {
+    throw new Error('_handleMessage must be implemented by subclass');
+  }
+
+  // ------------------------------------------------------------------
+  // Utility
+  // ------------------------------------------------------------------
+
+  _sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+module.exports = BaseAdapter;