onbuzz 3.9.10 → 4.0.0

package/src/services/channelFilter.js

@@ -0,0 +1,137 @@
+/**
+ * Channel filter — parses `<external to="alias">…</external>` blocks out of
+ * agent content so Discord / Telegram relays know what (and where) to send.
+ *
+ * Philosophy:
+ *   - Default is local. Nothing reaches an external channel unless the agent
+ *     explicitly wraps it in `<external>` tags. The local operator's web UI
+ *     continues to receive the raw WS broadcast unfiltered.
+ *   - Content inside `<external>` is relayed VERBATIM. Code, markdown, tool
+ *     JSON, task lists — all pass through. The agent decides; the filter
+ *     doesn't second-guess content shape.
+ *   - Granular routing via `to="alias"`:
+ *       <external>…</external>                   default  → broadcast to every bridged channel
+ *       <external to="*">…</external>            explicit → broadcast to every bridged channel
+ *       <external to="discord:#ops">…</external>          → that specific channel only
+ *       <external to="discord:#ops,telegram">…</external> → both listed channels
+ *
+ * API-path agnostic: runs on the fully-assembled assistant content emitted
+ * on the `stream_complete` WS broadcast. Both Responses API and Chat
+ * Completions converge on the same canonical content shape before that
+ * broadcast fires, so this filter is one pure function with no
+ * provider-specific branch.
+ */
+
+// Matches `<external>…</external>` or `<external to="…">…</external>` (case-insensitive).
+// The `to` attribute may be single- or double-quoted. Captured groups:
+//   1: the raw contents of the `to` attribute (or undefined)
+//   2: block body
+const EXTERNAL_TAG_RE =
+  /<external(?:\s+to\s*=\s*(?:"([^"]*)"|'([^']*)'))?>([\s\S]*?)<\/external>/gi;
+
+/**
+ * Parse every `<external>` block out of an agent content string.
+ *
+ * @param {string} content Raw assistant content.
+ * @returns {{ blocks: Array<{ to: string[]|null, text: string }> }}
+ *          `to === null`   → default routing (broadcast to every bridged
+ *                             channel the relaying service owns).
+ *          `to === ['*']`  → explicit broadcast (same as null).
+ *          `to === ['discord:#ops', 'telegram']` → specific aliases.
+ *          Callers (Discord / Telegram services) match their own aliases
+ *          against each block's `to` and send the `text` to matching
+ *          channels. `text` is the verbatim block contents with leading
+ *          and trailing whitespace trimmed — no other transformation.
+ */
+export function filterContentForExternalRelay(content) {
+  if (typeof content !== 'string' || content.length === 0) return { blocks: [] };
+
+  const blocks = [];
+  let m;
+  EXTERNAL_TAG_RE.lastIndex = 0;
+  while ((m = EXTERNAL_TAG_RE.exec(content)) !== null) {
+    const rawTo = m[1] ?? m[2] ?? null;
+    const body = (m[3] ?? '').replace(/^\s+|\s+$/g, '');
+    if (body.length === 0) continue;
+
+    let to = null;
+    if (rawTo !== null && rawTo.trim().length > 0) {
+      to = rawTo.split(',').map(s => s.trim()).filter(Boolean);
+      if (to.length === 0) to = null;
+    }
+    blocks.push({ to, text: body });
+  }
+  return { blocks };
+}
+
+/**
+ * Given a parsed block and the list of aliases a relay service owns,
+ * return the subset of aliases that should receive this block.
+ *
+ * A block with `to === null` or `to === ['*']` matches every owned alias.
+ * Otherwise the block's `to` list is matched case-insensitively against
+ * the service's aliases, with substring fallback so a block addressed to
+ * `discord:#ops` matches an owned alias `discord:guild-123:#ops` (useful
+ * because Discord aliases can carry guild prefixes the agent may omit).
+ *
+ * @param {{to: string[]|null, text: string}} block
+ * @param {string[]} ownedAliases  Aliases this relay service handles.
+ * @returns {string[]} Subset of `ownedAliases` that should receive the block.
+ */
+export function resolveBlockTargets(block, ownedAliases) {
+  if (!Array.isArray(ownedAliases) || ownedAliases.length === 0) return [];
+  if (!block.to || (block.to.length === 1 && block.to[0] === '*')) {
+    return [...ownedAliases];
+  }
+  const wanted = block.to.map(s => s.toLowerCase());
+  const matched = new Set();
+  for (const owned of ownedAliases) {
+    const ownedLc = String(owned).toLowerCase();
+    for (const w of wanted) {
+      if (ownedLc === w || ownedLc.endsWith(w) || ownedLc.includes(w)) {
+        matched.add(owned);
+        break;
+      }
+    }
+  }
+  return [...matched];
+}
+
+/**
+ * System-prompt paragraph listing the currently bridged channels and
+ * explaining the `<external to="…">` addressing scheme. The scheduler
+ * appends this once per turn, only when at least one channel is bridged.
+ *
+ * @param {Array<{alias:string, label?:string}>} channels
+ *        List of bridged channels the agent can address. `alias` is the
+ *        handle the agent uses in `to=`; `label` is a human-readable
+ *        description surfaced alongside the alias in the prompt.
+ * @returns {string} Guidance paragraph (empty string when channels is empty).
+ */
+export function getExternalChannelPromptGuidance(channels = []) {
+  if (!Array.isArray(channels) || channels.length === 0) return '';
+
+  const list = channels.map(c => {
+    const alias = String(c?.alias || '').trim();
+    if (!alias) return null;
+    const label = String(c?.label || '').trim();
+    return label ? `  - \`${alias}\` — ${label}` : `  - \`${alias}\``;
+  }).filter(Boolean).join('\n');
+
+  if (!list) return '';
+
+  return (
+    `\n\n## OUTPUT ROUTING\n` +
+    `This agent is bridged to external messaging channels. NOTHING you write is forwarded by default — your full response stays local for the operator, who sees everything unfiltered via the web UI.\n\n` +
+    `To send content to an external channel, wrap it in \`<external>…</external>\` tags. Content inside the tags is relayed verbatim (markdown, code blocks, tool summaries, task lists — whatever you write there is what the channel sees). Content outside the tags is never forwarded.\n\n` +
+    `Bridged channels you can address:\n${list}\n\n` +
+    `Addressing:\n` +
+    `  - \`<external>…</external>\` — broadcast to every bridged channel above.\n` +
+    `  - \`<external to="alias">…</external>\` — send only to that alias.\n` +
+    `  - \`<external to="aliasA,aliasB">…</external>\` — send to multiple specific aliases (comma-separated).\n` +
+    `  - \`<external to="*">…</external>\` — same as default (explicit broadcast).\n\n` +
+    `You can use multiple \`<external>\` blocks per response; each is delivered independently to its targets. Content with no \`<external>\` wrapper is never forwarded — perfect for private reasoning, tool calls, and inter-agent messages.`
+  );
+}
+
+export default { filterContentForExternalRelay, resolveBlockTargets, getExternalChannelPromptGuidance };

package/src/services/discordService.js

@@ -20,6 +20,7 @@ import { promises as fs } from 'fs';
 import path from 'path';
 import { getUserDataPaths, ensureUserDataDirs } from '../utilities/userDataDir.js';
 import { INTERFACE_TYPES } from '../utilities/constants.js';
+import { filterContentForExternalRelay, resolveBlockTargets } from './channelFilter.js';
 
 const DISCORD_STATUS = {
   DISCONNECTED: 'disconnected',
@@ -413,11 +414,15 @@ class DiscordService {
   async _routeToAgent(channelKey, agentId, text, discordMessage) {
     const sessionId = `discord-${channelKey.replace(':', '-')}`;
 
-    // Record recent interaction for response targeting
+    // Record recent interaction for response targeting. `channelName` and
+    // `guildName` are captured so we can surface a human-readable alias
+    // to the agent (see `getBridgedChannels`).
     this.recentInteractions.set(`${agentId}:${channelKey}`, {
       channelKey,
       channelId: discordMessage.channel.id,
-      guildId: discordMessage.guild.id,
+      channelName: discordMessage.channel.name || null,
+      guildId: discordMessage.guild?.id ?? null,
+      guildName: discordMessage.guild?.name ?? null,
       timestamp: Date.now()
     });
 
@@ -509,34 +514,113 @@ class DiscordService {
     const role = message.role || message.data?.role || message.message?.role;
     if (role === 'user' || role === 'tool') return;
 
-    // Find channels with recent interaction for this agent
-    const now = Date.now();
-    const channelsToRelay = [];
+    // Parse every <external>…</external> block out of the raw content.
+    // Content inside the tags is relayed verbatim — no stripping, no
+    // content-type discrimination. The web UI still sees the full raw
+    // message via the WS broadcast and is unaffected by this filter.
+    const { blocks } = filterContentForExternalRelay(content);
+    if (blocks.length === 0) {
+      this.logger?.debug?.('[DiscordService] no <external> blocks in agent response — nothing relayed', { agentId });
+      return;
+    }
+
+    // Collect every live Discord channel bridged to this agent. Drops
+    // stale entries past the interaction TTL as a side-effect.
+    const bridged = this._getBridgedChannelEntries(agentId);
+    if (bridged.length === 0) return;
+
+    // Map owned aliases → entry so we can look up channelId quickly after
+    // `resolveBlockTargets` tells us which aliases to send to.
+    const aliasToEntry = new Map(bridged.map(e => [e.alias, e]));
+    const ownedAliases = [...aliasToEntry.keys()];
 
+    const agent = this.agentPool ? await this.agentPool.getAgent(agentId) : null;
+    const agentName = agent?.name || agentId;
+
+    for (const block of blocks) {
+      const targets = resolveBlockTargets(block, ownedAliases);
+      for (const alias of targets) {
+        const entry = aliasToEntry.get(alias);
+        if (!entry) continue;
+        try {
+          await this._sendFormattedResponse(entry.channelId, agentName, block.text);
+        } catch (error) {
+          this.logger?.warn('[DiscordService] Failed to relay block', {
+            alias, channelId: entry.channelId, error: error.message
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Active Discord bridges for an agent, as entries tied to the relay
+   * pipeline. Each entry carries an `alias` the agent can use in
+   * `<external to="…">`. Expired entries (past INTERACTION_TTL_MS) are
+   * garbage-collected during the scan so alias lists stay honest.
+   *
+   * @param {string} agentId
+   * @returns {Array<{alias: string, label: string, channelKey: string, channelId: string, guildId: string|null, guildName: string|null, channelName: string|null}>}
+   * @private
+   */
+  _getBridgedChannelEntries(agentId) {
+    const now = Date.now();
+    const entries = [];
     for (const [key, interaction] of this.recentInteractions) {
       if (!key.startsWith(`${agentId}:`)) continue;
       if (now - interaction.timestamp > INTERACTION_TTL_MS) {
         this.recentInteractions.delete(key);
         continue;
       }
-      channelsToRelay.push(interaction);
+      const channel = interaction.channelName || interaction.channelId;
+      // Alias format: `discord:#<channel>` when we have a channel name;
+      // otherwise fall back to the bare channel id. Substring matching in
+      // `resolveBlockTargets` means the agent can write short forms like
+      // `discord:#ops` even if the canonical alias is longer.
+      const alias = interaction.channelName
+        ? `discord:#${interaction.channelName}`
+        : `discord:${interaction.channelId}`;
+      const label = interaction.guildName
+        ? `Discord channel #${interaction.channelName ?? interaction.channelId} in ${interaction.guildName}`
+        : `Discord channel ${interaction.channelName ?? interaction.channelId}`;
+      entries.push({
+        alias, label,
+        channelKey: interaction.channelKey,
+        channelId: interaction.channelId,
+        guildId: interaction.guildId,
+        guildName: interaction.guildName,
+        channelName: interaction.channelName,
+      });
     }
+    return entries;
+  }
 
-    if (channelsToRelay.length === 0) return;
-
-    const agent = this.agentPool ? await this.agentPool.getAgent(agentId) : null;
-    const agentName = agent?.name || agentId;
+  /**
+   * Compact alias list the scheduler surfaces in the system prompt so the
+   * agent can address specific Discord channels via `<external to="…">`.
+   *
+   * @param {string} agentId
+   * @returns {Array<{alias: string, label: string}>}
+   */
+  getBridgedChannels(agentId) {
+    if (!agentId || this.status !== DISCORD_STATUS.CONNECTED) return [];
+    return this._getBridgedChannelEntries(agentId).map(e => ({ alias: e.alias, label: e.label }));
+  }
 
-    for (const interaction of channelsToRelay) {
-      try {
-        await this._sendFormattedResponse(interaction.channelId, agentName, content);
-      } catch (error) {
-        this.logger?.warn('[DiscordService] Failed to relay response', {
-          channelId: interaction.channelId,
-          error: error.message
-        });
-      }
+  /**
+   * True when the agent has at least one live Discord bridge. Scheduler
+   * uses this to decide whether to inject the `<external>` prompt
+   * guidance for this turn (cheaper than calling getBridgedChannels when
+   * we only need a boolean).
+   */
+  isAgentBridged(agentId) {
+    if (!agentId || this.status !== DISCORD_STATUS.CONNECTED) return false;
+    const now = Date.now();
+    for (const [key, interaction] of this.recentInteractions) {
+      if (!key.startsWith(`${agentId}:`)) continue;
+      if (now - interaction.timestamp <= INTERACTION_TTL_MS) return true;
     }
+    return false;
   }
 
   async _relayPromptRequest(message) {

package/src/services/telegramService.js

@@ -18,6 +18,7 @@
 import { promises as fs } from 'fs';
 import path from 'path';
 import { getUserDataPaths, ensureUserDataDirs } from '../utilities/userDataDir.js';
+import { filterContentForExternalRelay, resolveBlockTargets } from './channelFilter.js';
 
 const TELEGRAM_STATUS = {
   DISCONNECTED: 'disconnected',
@@ -663,10 +664,66 @@ class TelegramService {
     const role = message.role || message.data?.role || message.message?.role;
     if (role === 'user' || role === 'tool') return;
 
+    // Parse every <external>…</external> block; content inside is relayed
+    // verbatim (see ./channelFilter.js). The local operator's web UI
+    // continues to see the full raw broadcast — this filter only decides
+    // what leaves the process.
+    const { blocks } = filterContentForExternalRelay(content);
+    if (blocks.length === 0) {
+      this.logger?.debug?.('[TelegramService] no <external> blocks in agent response — nothing relayed', { agentId });
+      return;
+    }
+
+    const bridged = this.getBridgedChannels(agentId);
+    if (bridged.length === 0) return;
+    const ownedAliases = bridged.map(c => c.alias);
+
     const agent = this.agentPool ? await this.agentPool.getAgent(agentId) : null;
     const agentName = agent?.name || agentId;
 
-    await this._sendFormattedResponse(this.chatId, agentName, content);
+    for (const block of blocks) {
+      const targets = resolveBlockTargets(block, ownedAliases);
+      if (targets.length === 0) continue;
+      // Today there is a single Telegram chat per agent, so any match
+      // ultimately sends to `this.chatId`. Loop defensively in case the
+      // service ever grows multi-chat support.
+      for (const alias of targets) {
+        try {
+          await this._sendFormattedResponse(this.chatId, agentName, block.text);
+        } catch (error) {
+          this.logger?.warn?.('[TelegramService] Failed to relay block', {
+            alias, error: error.message
+          });
+        }
+      }
+    }
+  }
+
+  /**
+   * Single-element alias list for this agent's Telegram bridge. The
+   * service currently tracks one chat, so the alias is a stable
+   * `telegram` handle; expanding to multi-chat later is additive (return
+   * one entry per chat).
+   *
+   * @param {string} agentId
+   * @returns {Array<{alias: string, label: string}>}
+   */
+  getBridgedChannels(agentId) {
+    if (!this.isAgentBridged(agentId)) return [];
+    return [{ alias: 'telegram', label: 'Telegram chat' }];
+  }
+
+  /**
+   * True when the agent is currently addressable from Telegram — the
+   * scheduler uses this to decide whether to inject the `<external>`
+   * prompt guidance for this turn.
+   *
+   * @param {string} agentId
+   * @returns {boolean}
+   */
+  isAgentBridged(agentId) {
+    if (!agentId || this.status !== TELEGRAM_STATUS.CONNECTED) return false;
+    return this.activeAgentIds.has(agentId);
   }
 
   // --- Smart Response Formatting ---

package/src/tools/fileSystemTool.js

@@ -1094,10 +1094,34 @@ SECURITY:
    * @private
    */
   resolvePath(filePath, workingDir) {
-    if (path.isAbsolute(filePath)) {
-      return path.normalize(filePath);
+    const resolved = path.isAbsolute(filePath)
+      ? path.normalize(filePath)
+      : path.resolve(workingDir, filePath);
+
+    // Guard against the "doubled folder" trap. Reasoning models lose track
+    // of the session CWD after a change-directory and re-prepend the
+    // project folder name to every relative path — turning
+    // CWD=".../foo" + "foo/bar/x.js" into ".../foo/foo/bar/x.js", which
+    // the filesystem silently creates. We detect this by scanning the
+    // FINAL resolved path for consecutive duplicate segments, so the
+    // guard fires whether the duplication came from (a) relative prefix
+    // (`foo/...` while inside `.../foo`), (b) relative mid-path
+    // (`pkg/foo/foo/bar`), or (c) an absolute path written out in full
+    // (`C:\...\foo\foo\bar`). Root-level duplicates like Windows drives
+    // are ignored by design (`C:\C:\...` is impossible in normalized form).
+    const segs = resolved.split(/[\\/]/).filter(Boolean);
+    for (let i = 1; i < segs.length; i++) {
+      if (segs[i].toLowerCase() === segs[i - 1].toLowerCase()) {
+        throw new Error(
+          `Refused: resolved path contains a duplicated segment "${segs[i]}" (${resolved}). ` +
+          `Current working directory: ${workingDir}. ` +
+          `This almost always means the project folder name was prepended to a relative path while the CWD is already inside it. ` +
+          `Drop the duplicated "${segs[i]}/" from the path — relative paths are resolved from the CWD — or pass an absolute path with no duplication.`
+        );
+      }
     }
-    return path.resolve(workingDir, filePath);
+
+    return resolved;
   }
 
   /**