@openagents-org/agent-launcher 0.2.150 → 0.2.152

package/src/adapters/codex.js

@@ -324,12 +324,15 @@ class CodexAdapter extends BaseAdapter {
           this._saveSessions();
           continue;
         } else {
-          await this.sendResponse(msgChannel, 'No response generated. Please try again.');
+          // Surface the actual reason (turn.failed message, stderr, exit code)
+          // instead of a generic "no response" — mirrors the OpenCode adapter
+          // so auth/model/network problems are actionable from the chat.
+          await this._sendRunFailure(msgChannel, result);
           return;
         }
       } catch (e) {
         this._log(`Error in subprocess: ${e.message}`);
-        await this.sendError(msgChannel, `Error: ${e.message}`);
+        await this.sendError(msgChannel, `⚠️ **Codex couldn't run** — ${CodexAdapter._redact(e.message)}`);
         return;
       }
     }
@@ -351,6 +354,7 @@ class CodexAdapter extends BaseAdapter {
       let hasToolUseSinceLastText = false;
       let lineBuffer = '';
       let stderrBuf = '';
+      let lastErrorMessage = '';
       let _pendingLines = Promise.resolve();
 
       if (proc.stderr) {
@@ -407,7 +411,12 @@ class CodexAdapter extends BaseAdapter {
         } else if (eventType === 'turn.failed') {
           const error = event.error || {};
           const errMsg = error.message || JSON.stringify(error);
+          lastErrorMessage = errMsg;
           this._log(`Turn failed: ${errMsg}`);
+        } else if (eventType === 'error') {
+          const errMsg = event.message || JSON.stringify(event);
+          lastErrorMessage = errMsg;
+          this._log(`Error event: ${errMsg}`);
         }
       };
 
@@ -442,6 +451,7 @@ class CodexAdapter extends BaseAdapter {
           responseText: responseTexts.join('\n').trim(),
           exitCode: code,
           stderr: stderrBuf,
+          errorMessage: lastErrorMessage,
         });
       });
 
@@ -452,6 +462,50 @@ class CodexAdapter extends BaseAdapter {
     });
   }
 
+  // ------------------------------------------------------------------
+  // Failure reporting
+  // ------------------------------------------------------------------
+
+  /**
+   * Post a user-visible failure carrying the actual reason a run produced no
+   * reply, instead of a generic "No response generated".
+   */
+  async _sendRunFailure(msgChannel, result) {
+    const detail = CodexAdapter._failureDetail(result);
+    const body = detail
+      ? `Codex failed to complete this run.\n\n> ${detail}`
+      : 'Codex finished without producing a reply. Please try again.';
+    await this.sendError(msgChannel, `⚠️ **Codex couldn't run** — ${body}`);
+  }
+
+  /**
+   * Pick the most informative failure detail from a run result:
+   * turn.failed / error event message → stderr tail → exit code. Redacted.
+   */
+  static _failureDetail({ errorMessage, stderr, exitCode } = {}) {
+    const stderrTail = String(stderr || '').trim().split('\n').slice(-5).join('\n').trim();
+    const raw = String(errorMessage || '').trim()
+      || stderrTail
+      || (exitCode ? `codex exited with code ${exitCode}` : '');
+    return CodexAdapter._redact(raw).slice(0, 500).trim();
+  }
+
+  /** Redact secrets (keys, tokens, bearer/authorization, query secrets) from diagnostics. */
+  static _redact(s) {
+    let out = String(s == null ? '' : s);
+    out = out
+      .replace(/\bsk-[A-Za-z0-9_-]{6,}/g, 'sk-[REDACTED]')
+      .replace(/\b(?:github_pat|gh[pousr])_[A-Za-z0-9_]{10,}/g, '[REDACTED_TOKEN]')
+      .replace(/\bxox[baprs]-[A-Za-z0-9-]{8,}/g, '[REDACTED_TOKEN]')
+      .replace(/\bAKIA[0-9A-Z]{12,}/g, '[REDACTED_KEY]')
+      .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}/g, '[REDACTED_JWT]')
+      .replace(/(authorization|api[_-]?key|x-api-key|token|bearer|secret|password|passwd)(["'\s:=]+)([^\s"',}]+)/gi,
+        (m, k, sep) => `${k}${sep}[REDACTED]`)
+      .replace(/([?&](?:api[_-]?key|key|token|access_token)=)[^&\s"']+/gi, '$1[REDACTED]')
+      .replace(/\b[A-Za-z0-9_-]{40,}\b/g, '[REDACTED]');
+    return out;
+  }
+
   // ------------------------------------------------------------------
   // Direct HTTP mode (fallback when CLI not available)
   // ------------------------------------------------------------------
@@ -467,11 +521,11 @@ class CodexAdapter extends BaseAdapter {
         }
         await this.sendResponse(msgChannel, responseText);
       } else {
-        await this.sendResponse(msgChannel, 'No response generated. Please try again.');
+        await this._sendRunFailure(msgChannel, {});
       }
     } catch (e) {
       this._log(`Error in direct API: ${e.message}`);
-      await this.sendError(msgChannel, `Error: ${e.message}`);
+      await this.sendError(msgChannel, `⚠️ **Codex couldn't run** — ${CodexAdapter._redact(e.message)}`);
     }
   }
 

package/src/adapters/cursor.js

@@ -16,7 +16,7 @@ const { execSync, spawn } = require('child_process');
 
 const BaseAdapter = require('./base');
 const { formatAttachmentsForPrompt, SESSION_DEFAULT_RE, generateSessionTitle } = require('./utils');
-const { buildCursorSkillMd } = require('./workspace-prompt');
+const { buildCursorSkillMd, workspaceSkillName } = require('./workspace-prompt');
 const { defaultAgentWorkdir, whichBinary, whereBinary } = require('../paths');
 
 const IS_WINDOWS = process.platform === 'win32';
@@ -308,7 +308,12 @@ class CursorAdapter extends BaseAdapter {
     const workDir = this.workingDir || defaultAgentWorkdir(this.agentName);
     const skillDir = path.join(workDir, '.cursor', 'skills');
     fs.mkdirSync(skillDir, { recursive: true });
-    const skillFile = path.join(skillDir, 'openagents-workspace.md');
+    // Per-agent filename: agents sharing a working directory used to clobber
+    // one shared openagents-workspace.md, so uploads carried the identity of
+    // whichever agent wrote the file last. Drop that legacy file so a stale
+    // copy (with another agent's embedded identity) can never be read again.
+    const skillFile = path.join(skillDir, `${workspaceSkillName(this.agentName)}.md`);
+    try { fs.unlinkSync(path.join(skillDir, 'openagents-workspace.md')); } catch {}
 
     const skillContent = buildCursorSkillMd({
       endpoint: this.endpoint,
@@ -330,7 +335,20 @@ class CursorAdapter extends BaseAdapter {
       throw new Error('Cursor CLI not found. Install with: curl https://cursor.com/install -fsSL | bash');
     }
 
-    const cmd = [agentBin, '-p', prompt, '--output-format', 'stream-json', '--trust', '--force'];
+    // Cursor has no system-prompt flag, so the CLI would otherwise learn its
+    // identity ONLY from whichever workspace skill it happens to open. With a
+    // shared working directory several agents' skills coexist (same
+    // description, different embedded identity), so every spawn must pin who
+    // this agent is and exactly which skill file is its interface — otherwise
+    // it can read a sibling's skill and upload under that agent's name.
+    const identityHeader =
+      `[workspace] You are agent '${this.agentName}'. For ANY workspace ` +
+      `operation (messages, files, agents, browser) read and follow ONLY the ` +
+      `'${workspaceSkillName(this.agentName)}' skill. Other ` +
+      `openagents-workspace-* skills belong to OTHER agents and carry the ` +
+      `wrong identity — never use them.\n\n`;
+
+    const cmd = [agentBin, '-p', identityHeader + prompt, '--output-format', 'stream-json', '--trust', '--force'];
 
     // Model selection
     const model = (this.agentEnv || process.env).CURSOR_MODEL;

package/src/adapters/decision-log.js

@@ -0,0 +1,181 @@
+/**
+ * Pure helpers for the Claude adapter's decision log ("constraint pinning").
+ *
+ * The decision log is a per-channel knowledge entry that records every
+ * decision the user has confirmed. The adapter re-reads it on every message
+ * and injects it into the CLI system prompt — the only position that survives
+ * both the CLI's auto-compaction and a session reset. Everything here is
+ * side-effect free so it can be unit tested without an adapter instance.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+
+/** Max characters a single recap line may occupy before being cut. */
+const RECAP_LINE_MAX_CHARS = 2000;
+
+/** Default budget for the pinned-decisions block inside the system prompt. */
+const PINNED_DECISIONS_MAX_CHARS = 4000;
+
+/**
+ * Canonical knowledge-entry title for a channel's decision log. The slug the
+ * backend derives from it is NOT stable (collisions get a numeric suffix), so
+ * lookups must match on this exact title, never on the slug.
+ */
+function decisionLogTitle(channelName) {
+  return `Decisions for channel ${channelName}`;
+}
+
+/**
+ * Stable hash of the decision log content. null/undefined and '' hash
+ * identically so "no entry yet" never reads as a change.
+ */
+function hashDecisions(content) {
+  return crypto.createHash('sha256').update(String(content || '').trim(), 'utf-8').digest('hex');
+}
+
+/**
+ * Fingerprint of everything the system prompt pins from the decision log —
+ * the entry id AND the content — used to detect that a persistent CLI
+ * process was spawned with an outdated prompt. Content alone is not enough:
+ * a deleted-and-recreated log can carry identical content under a new id,
+ * and a prompt still holding the old id would send updates to a dead entry.
+ */
+function decisionFingerprint(entryId, content) {
+  return crypto.createHash('sha256')
+    .update(`${entryId || ''}\u0000${String(content || '').trim()}`, 'utf-8')
+    .digest('hex');
+}
+
+/**
+ * Pick the channel's decision entry from a knowledge listing: exact-title
+ * matches only, earliest created_at wins (concurrent creates produce
+ * duplicates — the earliest is the one other turns have been updating).
+ * Returns { entry, duplicates } where duplicates counts the extra matches.
+ */
+function pickDecisionEntry(entries, channelName) {
+  const title = decisionLogTitle(channelName);
+  const matches = (entries || []).filter((e) => e && e.title === title);
+  if (matches.length === 0) return { entry: null, duplicates: 0 };
+  const sorted = matches.slice().sort((a, b) => {
+    // ISO-8601 strings compare chronologically as strings; entries without a
+    // timestamp are anomalous and sort last so a dated original wins.
+    const ka = a.created_at || '\uffff';
+    const kb = b.created_at || '\uffff';
+    return ka < kb ? -1 : ka > kb ? 1 : 0;
+  });
+  return { entry: sorted[0], duplicates: matches.length - 1 };
+}
+
+/**
+ * Fit the decision log into a character budget without ever cutting a line
+ * in half. Over budget, whole lines are kept from the head (earliest
+ * decisions) and the tail (latest decisions) with the middle dropped, so
+ * neither end of the log silently disappears.
+ * Returns { text, truncated, omitted }.
+ */
+function renderPinnedDecisions(content, { maxChars = PINNED_DECISIONS_MAX_CHARS } = {}) {
+  const text = String(content || '').trim();
+  if (!text) return { text: '', truncated: false, omitted: 0 };
+  if (text.length <= maxChars) return { text, truncated: false, omitted: 0 };
+
+  const lines = text.split('\n');
+  // Reserve room for the omission marker inserted between head and tail.
+  const budget = Math.max(maxChars - 80, 0);
+  const headBudget = Math.floor(budget / 2);
+
+  const head = [];
+  let used = 0;
+  let i = 0;
+  for (; i < lines.length; i++) {
+    const cost = lines[i].length + 1;
+    if (used + cost > headBudget) break;
+    head.push(lines[i]);
+    used += cost;
+  }
+
+  const tail = [];
+  let j = lines.length - 1;
+  for (; j >= i; j--) {
+    const cost = lines[j].length + 1;
+    if (used + cost > budget) break;
+    tail.unshift(lines[j]);
+    used += cost;
+  }
+
+  const omitted = lines.length - head.length - tail.length;
+  if (omitted <= 0) {
+    // Everything fit after all (short middle) — no marker needed.
+    return { text: [...head, ...tail].join('\n'), truncated: false, omitted: 0 };
+  }
+  const marker = `[… ${omitted} middle line(s) omitted — read the decision log entry for the full list …]`;
+  return {
+    text: [...head, marker, ...tail].join('\n'),
+    truncated: true,
+    omitted,
+  };
+}
+
+/** A message qualifies for the recap when it is real chat with content. */
+function isRecapEligible(msg, currentMessage) {
+  if (!msg) return false;
+  const mt = msg.messageType || 'chat';
+  if (mt === 'status' || mt === 'thinking' || mt === 'loading') return false;
+  const text = (msg.content || '').trim();
+  if (!text) return false;
+  if (text === currentMessage) return false;
+  return true;
+}
+
+function formatRecapLine(msg) {
+  const text = (msg.content || '').trim();
+  const who = msg.senderType === 'human'
+    ? (msg.senderName || 'user')
+    : (msg.senderName || 'agent');
+  const cut = text.length > RECAP_LINE_MAX_CHARS
+    ? text.slice(0, RECAP_LINE_MAX_CHARS) + '…'
+    : text;
+  return `[${who}] ${cut}`;
+}
+
+/**
+ * Build recap lines from the channel's opening messages (fetched ascending)
+ * and its most recent ones (fetched descending, already reversed to
+ * chronological). Head keeps the original requirement, tail keeps the live
+ * discussion; overlap is removed by event ID. An omission marker is inserted
+ * only when the two windows do not overlap, i.e. messages in between were
+ * actually dropped.
+ */
+function sampleRecap(headMsgs, tailMsgs, currentMessage, { headKeep = 5, tailKeep = 15 } = {}) {
+  const head = (headMsgs || [])
+    .filter((m) => isRecapEligible(m, currentMessage))
+    .slice(0, headKeep);
+  const tail = (tailMsgs || [])
+    .filter((m) => isRecapEligible(m, currentMessage))
+    .slice(-tailKeep);
+
+  const headIds = new Set(head.map((m) => m.messageId).filter(Boolean));
+  const tailDeduped = tail.filter((m) => !m.messageId || !headIds.has(m.messageId));
+  const windowsOverlap = tailDeduped.length < tail.length;
+
+  const lines = head.map(formatRecapLine);
+  if (head.length > 0 && tailDeduped.length > 0 && !windowsOverlap) {
+    lines.push('[… earlier messages omitted …]');
+  }
+  lines.push(...tailDeduped.map(formatRecapLine));
+  return lines;
+}
+
+module.exports = {
+  PINNED_DECISIONS_MAX_CHARS,
+  RECAP_LINE_MAX_CHARS,
+  decisionLogTitle,
+  hashDecisions,
+  decisionFingerprint,
+  pickDecisionEntry,
+  renderPinnedDecisions,
+  isRecapEligible,
+  formatRecapLine,
+  sampleRecap,
+};

package/src/adapters/index.js

@@ -19,6 +19,7 @@ const GooseAdapter = require('./goose');
 const CopilotAdapter = require('./copilot');
 const ClineAdapter = require('./cline');
 const AmpAdapter = require('./amp');
+const MiniSweAgentAdapter = require('./mini');
 
 const ADAPTER_MAP = {
   openclaw: OpenClawAdapter,
@@ -35,11 +36,12 @@ const ADAPTER_MAP = {
   copilot: CopilotAdapter,
   cline: ClineAdapter,
   amp: AmpAdapter,
+  'mini-swe-agent': MiniSweAgentAdapter,
 };
 
 /**
  * Create an adapter instance for the given agent type.
- * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp)
+ * @param {string} type - Agent type (openclaw, claude, codex, opencode, nanoclaw, cursor, hermes, gemini, kimi, aider, goose, copilot, cline, amp, mini-swe-agent)
  * @param {object} opts - Adapter constructor options
  * @returns {BaseAdapter}
  */
@@ -67,6 +69,7 @@ module.exports = {
   CopilotAdapter,
   ClineAdapter,
   AmpAdapter,
+  MiniSweAgentAdapter,
   createAdapter,
   ADAPTER_MAP,
 };