@friendlyrobot/discord-pi-agent 0.19.14 → 0.19.16

package/dist/discord-replies.d.ts

@@ -1,6 +1,10 @@
 import type { Message } from "discord.js";
-export declare function addWorkingReaction(message: Message): Promise<void>;
-export declare function removeWorkingReaction(message: Message): Promise<void>;
-export declare function sendReply(message: Message, text: string, opts?: {
-    codeFence?: boolean;
-}): Promise<void>;
+export declare const DEFAULT_WORKING_EMOJI = "\u2699\uFE0F";
+export declare function addWorkingReaction(message: Message, emoji?: string): Promise<void>;
+export declare function removeWorkingReaction(message: Message, emoji?: string): Promise<void>;
+export declare function sendReply(message: Message, text: string): Promise<void>;
+/**
+ * Sends a command response wrapped in triple backticks.
+ * Splits by newlines so each chunk stays within Discord's 2000-char limit.
+ */
+export declare function sendCommandReply(message: Message, text: string): Promise<void>;

package/dist/index.js

@@ -727,6 +727,7 @@ async function handleHelpCommand(trimmedInput, context) {
       "!compact - compact the persistent session",
       "!reset-session - start a fresh persistent session",
       "!reload - reload resources (AGENTS.md, extensions, skills, etc.)",
+      "!reaction - show or set the working reaction emoji",
       extraCommands,
       "Any other text goes to the agent session."
     ].filter(Boolean).join(`
@@ -887,6 +888,32 @@ async function handleResetSessionCommand(trimmedInput, context) {
     })
   };
 }
+async function handleReactionCommand(trimmedInput, _context) {
+  if (trimmedInput !== "!reaction" && !trimmedInput.startsWith("!reaction ")) {
+    return null;
+  }
+  const parts = trimmedInput.split(" ");
+  if (parts.length === 1) {
+    return {
+      handled: true,
+      response: `Current working reaction: ${_context.workingEmoji}
+` + `Usage: !reaction <emoji> to change it.
+` + `Examples: !reaction \uD83D\uDD04 or !reaction ⏳`
+    };
+  }
+  const emoji = parts.slice(1).join(" ").trim();
+  if (!emoji) {
+    return {
+      handled: true,
+      response: "Please provide an emoji. Example: !reaction \uD83D\uDD04"
+    };
+  }
+  return {
+    handled: true,
+    workingEmoji: emoji,
+    response: `Working reaction emoji set to ${emoji}`
+  };
+}
 var commandHandlers = [
   handleHelpCommand,
   handleArchiveCommand,
@@ -895,7 +922,8 @@ var commandHandlers = [
   handleModelCommand,
   handleCompactCommand,
   handleReloadCommand,
-  handleResetSessionCommand
+  handleResetSessionCommand,
+  handleReactionCommand
 ];
 async function executeSessionCommand(input, context) {
   const trimmedInput = input.trim();
@@ -1122,17 +1150,45 @@ function chunkMessage(text, maxChunkSize = SAFE_MESSAGE_LIMIT) {
 
 // src/discord-replies.ts
 var logger7 = createModuleLogger("discord-replies");
-var WORKING_EMOJI = "⚙️";
-async function addWorkingReaction(message) {
+var DISCORD_MESSAGE_LIMIT2 = 2000;
+var FENCE_OVERHEAD = 8;
+var MAX_CODE_FENCE_CONTENT = DISCORD_MESSAGE_LIMIT2 - FENCE_OVERHEAD;
+function chunkByLines(text, maxSize) {
+  const lines = text.split(`
+`);
+  const chunks = [];
+  let current = "";
+  for (const line of lines) {
+    const candidate = current ? current + `
+` + line : line;
+    if (candidate.length > maxSize) {
+      if (current) {
+        chunks.push(current);
+        current = line;
+      } else {
+        chunks.push(line.slice(0, maxSize));
+        current = line.slice(maxSize);
+      }
+    } else {
+      current = candidate;
+    }
+  }
+  if (current) {
+    chunks.push(current);
+  }
+  return chunks;
+}
+var DEFAULT_WORKING_EMOJI = "⚙️";
+async function addWorkingReaction(message, emoji = DEFAULT_WORKING_EMOJI) {
   try {
-    await message.react(WORKING_EMOJI);
+    await message.react(emoji);
   } catch (error) {
     logger7.debug({ messageId: message.id, error }, "failed to add working reaction");
   }
 }
-async function removeWorkingReaction(message) {
+async function removeWorkingReaction(message, emoji = DEFAULT_WORKING_EMOJI) {
   try {
-    const reaction = message.reactions.cache.get(WORKING_EMOJI);
+    const reaction = message.reactions.cache.get(emoji);
     if (reaction) {
       await reaction.users.remove(message.client.user);
     }
@@ -1140,7 +1196,7 @@ async function removeWorkingReaction(message) {
     logger7.debug({ messageId: message.id, error }, "failed to remove working reaction");
   }
 }
-async function sendReply(message, text, opts) {
+async function sendReply(message, text) {
   const channel = message.channel;
   if (!channel.isSendable()) {
     logger7.debug({
@@ -1148,10 +1204,7 @@ async function sendReply(message, text, opts) {
     }, "reply skipped, channel not sendable");
     return;
   }
-  const wrap = opts?.codeFence ? (c) => `\`\`\`
-${c}
-\`\`\`` : (c) => c;
-  const chunks = chunkMessage(text).map(wrap);
+  const chunks = chunkMessage(text);
   const [firstChunk, ...remainingChunks] = chunks;
   if (!firstChunk) {
     return;
@@ -1168,6 +1221,33 @@ ${c}
     }, "send reply failed");
   }
 }
+async function sendCommandReply(message, text) {
+  const channel = message.channel;
+  if (!channel.isSendable()) {
+    logger7.debug({
+      messageId: message.id
+    }, "command reply skipped, channel not sendable");
+    return;
+  }
+  const chunks = chunkByLines(text, MAX_CODE_FENCE_CONTENT).map((c) => `\`\`\`
+${c}
+\`\`\``);
+  const [firstChunk, ...remainingChunks] = chunks;
+  if (!firstChunk) {
+    return;
+  }
+  try {
+    await message.reply(firstChunk);
+    for (const chunk of remainingChunks) {
+      await channel.send(chunk);
+    }
+  } catch (error) {
+    logger7.error({
+      messageId: message.id,
+      error
+    }, "send command reply failed");
+  }
+}
 
 // src/media-description.ts
 var logger8 = createModuleLogger("media-description");
@@ -1533,10 +1613,15 @@ ${attachment.content}`;
   const commandResult = await executeSessionCommand(content, {
     agentService,
     promptQueue,
-    session
+    session,
+    workingEmoji: entry.workingEmoji
   });
   if (commandResult.handled) {
     stopTypingForChannel(channelKey);
+    if (commandResult.workingEmoji) {
+      entry.workingEmoji = commandResult.workingEmoji;
+      logger11.info({ scope, emoji: commandResult.workingEmoji }, "working emoji updated");
+    }
     if (commandResult.archive && scope.startsWith("thread:")) {
       logger11.info({ scope }, "archiving thread");
       const archiveChannel = message.channel;
@@ -1561,7 +1646,7 @@ ${commandResult.response ?? "Archiving..."}
       hasResponse: Boolean(commandResult.response)
     }, `command handled: ${content}`);
     if (commandResult.response) {
-      await sendReply(message, commandResult.response, { codeFence: true });
+      await sendCommandReply(message, commandResult.response);
     }
     return;
   }
@@ -1570,7 +1655,7 @@ ${commandResult.response ?? "Archiving..."}
     logger11.debug({ messageId: message.id }, "channel not sendable");
     return;
   }
-  await addWorkingReaction(message);
+  await addWorkingReaction(message, entry.workingEmoji);
   const queuePosition = promptQueue.getSnapshot().pending;
   if (queuePosition > 0) {
     await sendReply(message, `Queued. ${queuePosition} request(s) ahead of this one.`);
@@ -1595,7 +1680,7 @@ ${commandResult.response ?? "Archiving..."}
     });
   } finally {
     stopTypingForChannel(channelKey);
-    await removeWorkingReaction(message);
+    await removeWorkingReaction(message, entry.workingEmoji);
   }
   await sendReply(message, response);
 }
@@ -1716,7 +1801,8 @@ class SessionRegistry {
     const entry = {
       session,
       promptQueue,
-      createdAt: new Date
+      createdAt: new Date,
+      workingEmoji: DEFAULT_WORKING_EMOJI
     };
     this.scopes.set(scope, entry);
     logger13.debug({

package/dist/session-commands.d.ts

@@ -6,10 +6,14 @@ export type CommandResult = {
     response?: string;
     /** Set to true when the command wants to archive the current thread. */
     archive?: boolean;
+    /** When set, update the session's working reaction emoji. */
+    workingEmoji?: string;
 };
 export type CommandContext = {
     agentService: AgentService;
     promptQueue: PromptQueue;
     session?: AgentSession;
+    /** Current working reaction emoji for this session. */
+    workingEmoji: string;
 };
 export declare function executeSessionCommand(input: string, context: CommandContext): Promise<CommandResult>;

package/dist/session-registry.d.ts

@@ -6,6 +6,7 @@ export type ScopedSessionEntry = {
     session: AgentSession;
     promptQueue: PromptQueue;
     createdAt: Date;
+    workingEmoji: string;
 };
 /**
  * Derive a deterministic session directory from a scope key.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friendlyrobot/discord-pi-agent",
-  "version": "0.19.14",
+  "version": "0.19.16",
   "description": "Reusable Discord gateway for persistent pi agent sessions",
   "license": "MIT",
   "type": "module",