@kolisachint/hoobot 0.0.6 → 0.0.7

package/.env.example

@@ -16,6 +16,13 @@ SLACK_APP_TOKEN=
 # Required: the bot refuses to start without it.
 ALLOWED_USER_IDS=758289752645959720
 
+# Optional (Slack): member IDs of other bots, e.g. a companion hoobot,
+# that may call this bot by mentioning it. Empty = bots are ignored.
+# Each gets PEER_TURNS answers per thread; then an allowed user is asked
+# (Yes / No buttons) for PEER_TURNS more. A person calling resets it.
+PEER_BOT_IDS=
+PEER_TURNS=2
+
 # Only answer in the Hoo server (Discord only).
 GUILD_ID=1554149385623838922
 

package/README.md

@@ -143,6 +143,13 @@ work together. Each has its own hoocode conversation, model and settings.
 - **Threads:** open a thread for a side task. It gets its own
   conversation in the same folder; its first call also reads the channel
   messages that led up to it. Results stay in the thread.
+- **Two bots talking (Slack):** set `PEER_BOT_IDS` to another bot's
+  member ID (e.g. a companion hoobot) and it can call this one by
+  mentioning it; `@name` of a peer in an answer becomes a real mention.
+  To stop loops, a peer gets `PEER_TURNS` (default 2) answers per thread;
+  then an allowed user gets **Yes / No** buttons for 2 more. A person
+  calling the bot in that thread starts the count over. Peers can't run
+  `!` commands. Other bots are still ignored.
 - **Steer:** calling it while it's busy redirects the current run.
 - **Needs** the **Read Message History** permission in those channels
   (Slack: the bot must be in the channel); without it, it works with no
@@ -219,6 +226,7 @@ the thread; the first answer wins and the others see it resolved.
 | `src/chat.ts` | The `ChatSpace` interface a session talks to |
 | `src/discord.ts` | Discord side: mentions and replies → calls; channels and threads → spaces; buttons, menus |
 | `src/slack.ts` | Slack side (Socket Mode): mentions → calls; channels and threads → spaces; Block Kit buttons, menus |
+| `src/peers.ts` | Peer bots: turns per thread, `@name` → Slack mention |
 | `src/mrkdwn.ts` | Markdown → Slack mrkdwn, and Slack text → plain text |
 | `src/context.ts` | What people said since the bot last read a space |
 | `src/session.ts` | One app-server thread per channel or thread; notifications → messages, buttons → approvals |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kolisachint/hoobot",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Use hoocode from Discord and Slack: a chat bot that talks the Codex app-server protocol",
   "type": "module",
   "license": "MIT",
@@ -38,7 +38,7 @@
     "start": "bun src/index.ts",
     "dev": "bun --watch src/index.ts",
     "typecheck": "tsc --noEmit",
-    "test": "bun test test/mrkdwn.test.ts test/slack.test.ts test/format.test.ts test/codex-client.test.ts test/summary.test.ts test/session.test.ts test/config.test.ts test/context.test.ts test/attachments.test.ts test/inbound.test.ts",
+    "test": "bun test test/mrkdwn.test.ts test/slack.test.ts test/format.test.ts test/codex-client.test.ts test/summary.test.ts test/session.test.ts test/config.test.ts test/context.test.ts test/attachments.test.ts test/inbound.test.ts test/peers.test.ts",
     "check": "bun run typecheck && bun run test"
   }
 }

package/src/config.ts

@@ -24,6 +24,13 @@ export const config = {
    * (digits) and Slack member IDs (`U0123ABCD`) in one list.
    */
   allowedUserIds: new Set(list("ALLOWED_USER_IDS")),
+  /**
+   * Slack user IDs of other bots (e.g. a companion hoobot) that may call
+   * this one by mentioning it. Empty = bots are ignored.
+   */
+  peerBotIds: new Set(list("PEER_BOT_IDS")),
+  /** Answers a peer bot gets per thread before an allowed user is asked for more. */
+  peerTurns: Math.max(1, Number(process.env.PEER_TURNS ?? 2) || 2),
   /** Optional: restrict to one Discord server / some channels (Discord or Slack channel IDs). */
   guildId: process.env.GUILD_ID?.trim() || undefined,
   channelIds: new Set(list("CHANNEL_IDS")),

package/src/core.ts

@@ -102,6 +102,8 @@ export interface Call {
   context(state: { linked: boolean; seen: string | null }): Promise<string>;
   /** The message this one replies to, unless it's the bot's own. */
   replyTo?(): Promise<{ context: ContextMessage | null; message: FileMessage } | null>;
+  /** Called by a peer bot (`PEER_BOT_IDS`), not a person: no allow list, no commands. */
+  peer?: boolean;
   /** Downloads a file (Slack needs the bot token). */
   fetcher?: Fetcher;
 }
@@ -136,11 +138,13 @@ export function helpText(label: string, menu: string): string {
 export async function handleCall(call: Call, help: string): Promise<void> {
   const { space } = call;
   // Only allowed users can call the bot (everyone's messages still count as context).
-  if (!config.allowedUserIds.has(call.userId)) {
+  if (!call.peer && !config.allowedUserIds.has(call.userId)) {
     await call.reply("Sorry, you're not on this bot's allow list.");
     return;
   }
   const text = call.text.trim();
+  // Peers talk; they don't run commands or get help.
+  if (call.peer && (!text || text.startsWith("!"))) return;
   if (!text && call.files.length === 0) {
     await call.reply(help);
     return;

package/src/mrkdwn.ts

@@ -58,6 +58,12 @@ function prose(text: string): string {
     links.push(`<${url.replace(/[<>|]/g, encodeURIComponent)}|${escape(label).replace(/\|/g, "¦")}>`);
     return `\u0002${links.length - 1}\u0002`;
   });
+  // Slack mentions (`<@U123>`) stay as they are, so a bot can tag another.
+  const mentions: string[] = [];
+  s = s.replace(/<@([UW][A-Z0-9]+)>/g, (m) => {
+    mentions.push(m);
+    return `\u0003${mentions.length - 1}\u0003`;
+  });
   s = escape(s);
   s = s
     .replace(/\*\*(?=\S)(.+?)(?<=\S)\*\*/g, `${B}$1${B}`)
@@ -65,7 +71,9 @@ function prose(text: string): string {
     .replace(/(^|[^\w*])\*(?=\S)([^*]+?)(?<=\S)\*(?![\w*])/g, "$1_$2_")
     .replace(/~~(?=\S)(.+?)(?<=\S)~~/g, "~$1~")
     .replaceAll(B, "*");
-  return s.replace(/\u0002(\d+)\u0002/g, (_, i: string) => links[Number(i)]!);
+  return s
+    .replace(/\u0002(\d+)\u0002/g, (_, i: string) => links[Number(i)]!)
+    .replace(/\u0003(\d+)\u0003/g, (_, i: string) => mentions[Number(i)]!);
 }
 
 /**

package/src/peers.ts

@@ -0,0 +1,65 @@
+/**
+ * Peer bots: other bots (e.g. a companion hoobot) that may call this one.
+ *
+ * Bots answering bots can loop forever, so each thread has a budget: a
+ * peer gets `PEER_TURNS` answers per thread. When it's used up, an allowed
+ * user is asked (Yes / No buttons) whether to grant `PEER_TURNS` more.
+ * A call from a person in the thread starts a fresh budget.
+ */
+export class TurnBudget {
+  private spaces = new Map<string, { used: number; limit: number }>();
+
+  constructor(readonly turns: number) {}
+
+  private get(space: string) {
+    let s = this.spaces.get(space);
+    if (!s) {
+      s = { used: 0, limit: this.turns };
+      this.spaces.set(space, s);
+      if (this.spaces.size > 1000) this.spaces.delete(this.spaces.keys().next().value!);
+    }
+    return s;
+  }
+
+  /** Use one peer turn; `false` when the budget is spent (nothing is used). */
+  take(space: string): boolean {
+    const s = this.get(space);
+    if (s.used >= s.limit) return false;
+    s.used++;
+    return true;
+  }
+
+  /** Allow `turns` more peer turns here. */
+  grant(space: string): void {
+    this.get(space).limit += this.turns;
+  }
+
+  /** A person called: start over. */
+  reset(space: string): void {
+    this.spaces.delete(space);
+  }
+
+  used(space: string): number {
+    return this.spaces.get(space)?.used ?? 0;
+  }
+}
+
+/**
+ * `@name` for a known peer → a real Slack mention (`<@U123>`), so the model
+ * can tag the other bot by name. Runs on mrkdwn (after conversion).
+ */
+export function linkMentions(mrkdwn: string, peers: Map<string, string>): string {
+  if (!peers.size) return mrkdwn;
+  // Code (fenced or inline) is left alone.
+  return mrkdwn
+    .split(/(```[\s\S]*?```|`[^`\n]*`)/)
+    .map((part, i) => {
+      if (i % 2 === 1) return part;
+      for (const [name, id] of peers) {
+        const re = new RegExp(`(^|[^\\w<@])@${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\w-])`, "gi");
+        part = part.replace(re, `$1<@${id}>`);
+      }
+      return part;
+    })
+    .join("");
+}

package/src/slack.ts

@@ -16,7 +16,8 @@ import { config, workdirFor } from "./config.ts";
 import { gatherContext, type MessageLike, type SpaceLike } from "./context.ts";
 import type { ChatSpace, Choice, Picked, Posted } from "./chat.ts";
 import { handleCall, helpText } from "./core.ts";
-import { fromMrkdwn, toMrkdwn } from "./mrkdwn.ts";
+import { fromMrkdwn, toMrkdwn as mrkdwn } from "./mrkdwn.ts";
+import { linkMentions, TurnBudget } from "./peers.ts";
 import type { AttachmentLike, Fetcher } from "./inbound.ts";
 
 const HELP = helpText("Slack", "a menu");
@@ -89,6 +90,12 @@ export class Slack {
   /** Recent event ids, so a redelivered event isn't answered twice. */
   private seen = new Set<string>();
   private nonce = 0;
+  /** Peer bots by lowercase name → user id, so `@name` in an answer becomes a mention. */
+  private peers = new Map<string, string>();
+  /** Answers to peer bots per thread (see src/peers.ts). */
+  private budget = new TurnBudget(config.peerTurns);
+  /** Spaces where "allow more turns?" is already asked. */
+  private asking = new Set<string>();
 
   constructor(botToken: string, appToken: string) {
     this.web = new WebClient(botToken, { logLevel: LogLevel.ERROR });
@@ -108,10 +115,19 @@ export class Slack {
   async start(): Promise<void> {
     const auth = await this.web.auth.test();
     this.botUserId = String(auth.user_id);
+    for (const id of config.peerBotIds) {
+      if (id === this.botUserId) continue;
+      const info: any = await this.web.users.info({ user: id }).catch(() => null);
+      for (const n of [info?.user?.name, info?.user?.profile?.display_name, info?.user?.real_name]) {
+        if (n && /^[\w.-]+$/.test(n)) this.peers.set(String(n).toLowerCase(), id);
+      }
+      if (!info) console.error(`PEER_BOT_IDS: can't look up ${id}`);
+    }
     this.socket.on("message", (e: any) => this.onEvent(e));
     this.socket.on("interactive", (e: any) => this.onInteractive(e));
     await this.socket.start();
     console.log(`Slack: logged in as @${auth.user} in ${auth.team}`);
+    if (this.peers.size) console.log(`Slack: peer bots ${[...new Set(this.peers.keys())].map((n) => "@" + n).join(", ")} (${config.peerTurns} turns per thread)`);
   }
 
   async stop(): Promise<void> {
@@ -145,7 +161,10 @@ export class Slack {
   }
 
   private async onMessage(event: any) {
-    if (!event || event.bot_id || !event.user || event.user === this.botUserId) return;
+    if (!event || !event.user || event.user === this.botUserId) return;
+    // Bots are ignored, except peers (PEER_BOT_IDS).
+    const peer = !!event.bot_id || config.peerBotIds.has(event.user);
+    if (peer && !config.peerBotIds.has(event.user)) return;
     if (!USER_SUBTYPES.has(event.subtype)) return;
     // Channels and private channels only, like Discord's text channels.
     if (event.channel_type !== "channel" && event.channel_type !== "group") return;
@@ -158,14 +177,22 @@ export class Slack {
 
     const threadTs: string | undefined = event.thread_ts && event.thread_ts !== event.ts ? event.thread_ts : undefined;
     const space = this.space(channel, threadTs);
+    if (!peer) this.budget.reset(space.id);
+    else if (!(await this.peerTurn(space))) return;
     const history = this.history(channel, threadTs);
+    const author = await this.name(event.user);
+    let said = fromMrkdwn(text, (id) => this.cachedName(id));
+    if (peer) {
+      said += `\n\n(${author} is a bot. To answer it, mention @${author}; leave the mention out to end the conversation.)`;
+    }
     await handleCall(
       {
         space,
         userId: event.user,
-        author: await this.name(event.user),
+        author,
+        peer,
         messageId: event.ts,
-        text: fromMrkdwn(text, (id) => this.cachedName(id)),
+        text: said,
         files: slackFiles(event.files),
         workdir: workdirFor(channel),
         reply: (t) => space.send(t),
@@ -177,11 +204,51 @@ export class Slack {
     );
   }
 
+  /**
+   * Use one peer turn here. When they're spent, ask an allowed user
+   * (Yes / No) for more; `false` = don't answer.
+   */
+  private async peerTurn(space: ChatSpace): Promise<boolean> {
+    if (this.budget.take(space.id)) return true;
+    if (this.asking.has(space.id)) return false;
+    this.asking.add(space.id);
+    try {
+      const n = config.peerTurns;
+      const { msg, pick } = await space.choose(
+        `I've answered the other bot ${this.budget.used(space.id)} times in this thread. Allow ${n} more turns?`,
+        "buttons",
+        [
+          { label: `Yes, ${n} more`, value: "yes", style: "primary" },
+          { label: "No, stop", value: "no", style: "danger" },
+        ],
+        config.approvalTimeoutMs,
+      );
+      const picked = await pick.catch(() => null);
+      if (!picked) {
+        await msg.edit("No answer, so the bots stop talking here.").catch(() => {});
+        return false;
+      }
+      if (picked.value !== "yes") {
+        await picked.update(`${picked.user} said stop. The bots stop talking here.`).catch(() => {});
+        return false;
+      }
+      await picked.update(`${picked.user} allowed ${n} more turns.`).catch(() => {});
+      this.budget.grant(space.id);
+      return this.budget.take(space.id);
+    } finally {
+      this.asking.delete(space.id);
+    }
+  }
+
+  /** Slack mrkdwn, with `@peer` turned into a real mention. */
+  private toMrkdwn = (md: string) => linkMentions(mrkdwn(md), this.peers);
+
   // ── Spaces ─────────────────────────────────────────────────────────────────
 
   /** A Slack channel or thread as a `ChatSpace`. */
   space(channel: string, threadTs?: string): ChatSpace {
     const web = this.web;
+    const toMrkdwn = this.toMrkdwn;
     const posted = (ts: string | undefined): Posted => ({
       edit: (text) => (ts ? web.chat.update({ channel, ts, text: toMrkdwn(text), blocks: [] }) : Promise.resolve()),
       delete: () => (ts ? web.chat.delete({ channel, ts }) : Promise.resolve()),
@@ -273,7 +340,7 @@ export class Slack {
     pending.resolve({
       value,
       user: body.user?.username ?? body.user?.name ?? (await this.name(userId)),
-      update: (text) => this.web.chat.update({ channel, ts, text: toMrkdwn(text), blocks: [] }),
+      update: (text) => this.web.chat.update({ channel, ts, text: this.toMrkdwn(text), blocks: [] }),
     });
   }