Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

extensions/telegram/src/status.test.ts

@@ -0,0 +1,489 @@
+// Telegram tests cover status plugin behavior.
+import type { ChannelAccountSnapshot } from "openclaw/plugin-sdk/channel-contract";
+import { DEFAULT_EMOJIS } from "openclaw/plugin-sdk/channel-feedback";
+import { describe, expect, it } from "vitest";
+import type { TelegramChatDetails, TelegramGetChat } from "./bot/types.js";
+import { collectTelegramStatusIssues } from "./status-issues.js";
+import {
+  buildTelegramStatusReactionVariants,
+  extractTelegramAllowedEmojiReactions,
+  isTelegramSupportedReactionEmoji,
+  resolveTelegramAllowedEmojiReactions,
+  resolveTelegramReactionVariant,
+  resolveTelegramStatusReactionEmojis,
+} from "./status-reaction-variants.js";
+
+type StatusIssue = ReturnType<typeof collectTelegramStatusIssues>[number];
+
+function expectIssueFields(issue: StatusIssue | undefined, expected: Partial<StatusIssue>): void {
+  if (!issue) {
+    throw new Error("expected status issue");
+  }
+  for (const [key, value] of Object.entries(expected)) {
+    expect(issue[key as keyof StatusIssue]).toBe(value);
+  }
+}
+
+function expectIssueListContainsFields(
+  issues: StatusIssue[],
+  expected: Partial<StatusIssue>,
+): void {
+  const match = issues.find((issue) =>
+    Object.entries(expected).every(([key, value]) => issue[key as keyof StatusIssue] === value),
+  );
+  expectIssueFields(match, expected);
+}
+
+function expectIssueMessageContains(issues: StatusIssue[], text: string): void {
+  expect(issues.map((issue) => issue.message).join("\n")).toContain(text);
+}
+
+describe("collectTelegramStatusIssues", () => {
+  it("reports privacy-mode and wildcard unmentioned-group configuration risks", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        allowUnmentionedGroups: true,
+        audit: {
+          hasWildcardUnmentionedGroups: true,
+          unresolvedGroups: 2,
+        },
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expectIssueListContainsFields(issues, {
+      channel: "telegram",
+      accountId: "main",
+      kind: "config",
+    });
+    expectIssueMessageContains(issues, "privacy mode");
+    expectIssueMessageContains(issues, 'uses "*"');
+    expectIssueMessageContains(issues, "unresolvedGroups=2");
+  });
+
+  it("reports unreachable groups with match metadata", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        audit: {
+          groups: [
+            {
+              chatId: "-100123",
+              ok: false,
+              status: "left",
+              error: "403",
+              matchKey: "alerts",
+              matchSource: "channels.telegram.groups",
+            },
+          ],
+        },
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expect(issues).toHaveLength(1);
+    expectIssueFields(issues[0], {
+      channel: "telegram",
+      accountId: "main",
+      kind: "runtime",
+    });
+    expect(issues[0]?.message).toContain("Group -100123 not reachable");
+    expect(issues[0]?.message).toContain("alerts");
+    expect(issues[0]?.message).toContain("channels.telegram.groups");
+  });
+
+  it("reports polling runtime state that never completed getUpdates after startup grace", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        running: true,
+        mode: "polling",
+        connected: false,
+        lastStartAt: Date.now() - 121_000,
+        lastError: "network timeout",
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expect(issues).toHaveLength(1);
+    expectIssueFields(issues[0], {
+      channel: "telegram",
+      accountId: "main",
+      kind: "runtime",
+    });
+    expect(issues[0]?.message).toContain("has not completed a successful getUpdates call");
+    expect(issues[0]?.message).toContain("network timeout");
+    expect(issues[0]?.fix).toContain("channels status --probe");
+  });
+
+  it("reports isolated polling spool backlog stalls distinctly from startup failures", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        running: true,
+        mode: "polling",
+        connected: false,
+        lastStartAt: Date.now() - 121_000,
+        lastError:
+          "Telegram isolated polling spool backlog stalled behind update 42 on lane telegram:123 for 1500100ms; marking polling unhealthy until the backlog drains.",
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expect(issues).toHaveLength(1);
+    expectIssueFields(issues[0], {
+      channel: "telegram",
+      accountId: "main",
+      kind: "runtime",
+    });
+    expect(issues[0]?.message).toContain("spool backlog is stalled");
+    expect(issues[0]?.message).not.toContain("has not completed a successful getUpdates call");
+  });
+
+  it("reports isolated polling spool handler timeouts distinctly from startup failures", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        running: true,
+        mode: "polling",
+        connected: false,
+        lastStartAt: Date.now() - 121_000,
+        lastError:
+          "Telegram isolated polling spool handler timed out behind update 42 on lane telegram:123 after 1500100ms; marking the update failed and restarting isolated ingress so later updates can drain.",
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expect(issues).toHaveLength(1);
+    expectIssueFields(issues[0], {
+      channel: "telegram",
+      accountId: "main",
+      kind: "runtime",
+    });
+    expect(issues[0]?.message).toContain("spool backlog is stalled");
+    expect(issues[0]?.message).not.toContain("has not completed a successful getUpdates call");
+  });
+
+  it("does not report polling startup before the connect grace expires", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        running: true,
+        mode: "polling",
+        connected: false,
+        lastStartAt: Date.now() - 60_000,
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expect(issues).toStrictEqual([]);
+  });
+
+  it("reports stale polling transport activity after successful getUpdates stops refreshing", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        running: true,
+        mode: "polling",
+        connected: true,
+        lastStartAt: Date.now() - 60 * 60_000,
+        lastTransportActivityAt: Date.now() - 31 * 60_000,
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expect(issues).toHaveLength(1);
+    expectIssueFields(issues[0], {
+      channel: "telegram",
+      accountId: "main",
+      kind: "runtime",
+    });
+    expect(issues[0]?.message).toContain("polling transport is stale");
+  });
+
+  it("does not report inherited stale transport activity during a fresh polling lifecycle", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        running: true,
+        mode: "polling",
+        connected: true,
+        lastStartAt: Date.now() - 60_000,
+        lastTransportActivityAt: Date.now() - 2 * 60 * 60_000,
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expect(issues).toStrictEqual([]);
+  });
+
+  it("reports webhook runtime state that never completed setWebhook after startup grace", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        running: true,
+        mode: "webhook",
+        connected: false,
+        lastStartAt: Date.now() - 10 * 60_000,
+        lastError: "fetch failed",
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expect(issues).toHaveLength(1);
+    expectIssueFields(issues[0], {
+      channel: "telegram",
+      accountId: "main",
+      kind: "runtime",
+    });
+    expect(issues[0]?.message).toContain("setWebhook has not completed");
+    expect(issues[0]?.message).toContain("fetch failed");
+    expect(issues[0]?.fix).toContain("webhook URL");
+  });
+
+  it("does not report webhook startup before the connect grace expires", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        running: true,
+        mode: "webhook",
+        connected: false,
+        lastStartAt: Date.now() - 60_000,
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expect(issues).toStrictEqual([]);
+  });
+
+  it("does not report an advertised webhook just because no user updates arrived", () => {
+    const issues = collectTelegramStatusIssues([
+      {
+        accountId: "main",
+        enabled: true,
+        configured: true,
+        running: true,
+        mode: "webhook",
+        connected: true,
+        lastStartAt: Date.now() - 60 * 60_000,
+      } as ChannelAccountSnapshot,
+    ]);
+
+    expect(issues).toStrictEqual([]);
+  });
+
+  it("ignores accounts that are not both enabled and configured", () => {
+    expect(
+      collectTelegramStatusIssues([
+        {
+          accountId: "main",
+          enabled: false,
+          configured: true,
+        } as ChannelAccountSnapshot,
+      ]),
+    ).toStrictEqual([]);
+  });
+});
+
+describe("resolveTelegramStatusReactionEmojis", () => {
+  it("falls back to Telegram-safe defaults for empty overrides", () => {
+    const result = resolveTelegramStatusReactionEmojis({
+      initialEmoji: "👀",
+      overrides: {
+        thinking: "   ",
+        done: "\n",
+      },
+    });
+
+    expect(result.queued).toBe("👀");
+    expect(result.thinking).toBe(DEFAULT_EMOJIS.thinking);
+    expect(result.done).toBe(DEFAULT_EMOJIS.done);
+  });
+
+  it("preserves explicit non-empty overrides", () => {
+    const result = resolveTelegramStatusReactionEmojis({
+      initialEmoji: "👀",
+      overrides: {
+        thinking: "🫡",
+        done: "🎉",
+      },
+    });
+
+    expect(result.thinking).toBe("🫡");
+    expect(result.done).toBe("🎉");
+  });
+});
+
+describe("buildTelegramStatusReactionVariants", () => {
+  it("puts requested emoji first and appends Telegram fallbacks", () => {
+    const variants = buildTelegramStatusReactionVariants({
+      ...DEFAULT_EMOJIS,
+      coding: "🛠️",
+    });
+
+    expect(variants.get("🛠️")).toEqual(["🛠️", "👨‍💻", "🔥", "⚡"]);
+  });
+});
+
+describe("isTelegramSupportedReactionEmoji", () => {
+  it("accepts Telegram-supported reaction emojis", () => {
+    expect(isTelegramSupportedReactionEmoji("👀")).toBe(true);
+    expect(isTelegramSupportedReactionEmoji("👨‍💻")).toBe(true);
+  });
+
+  it("rejects unsupported emojis", () => {
+    expect(isTelegramSupportedReactionEmoji("🫠")).toBe(false);
+  });
+});
+
+describe("extractTelegramAllowedEmojiReactions", () => {
+  it("returns undefined when chat does not include available_reactions", () => {
+    const result = extractTelegramAllowedEmojiReactions({ id: 1 } satisfies TelegramChatDetails);
+    expect(result).toBeUndefined();
+  });
+
+  it("returns null when available_reactions is omitted/null", () => {
+    const result = extractTelegramAllowedEmojiReactions({
+      available_reactions: null,
+    } satisfies TelegramChatDetails);
+    expect(result).toBeNull();
+  });
+
+  it("extracts emoji reactions only", () => {
+    const result = extractTelegramAllowedEmojiReactions({
+      available_reactions: [
+        { type: "emoji", emoji: "👍" },
+        { type: "custom_emoji", custom_emoji_id: "abc" },
+        { type: "emoji", emoji: "🔥" },
+      ],
+    } satisfies TelegramChatDetails);
+    expect(result ? Array.from(result).toSorted() : null).toEqual(["👍", "🔥"]);
+  });
+
+  it("treats malformed available_reactions payloads as an empty allowlist instead of throwing", () => {
+    expect(
+      extractTelegramAllowedEmojiReactions({
+        available_reactions: { type: "emoji", emoji: "👍" },
+      } as never),
+    ).toEqual(new Set<string>());
+  });
+});
+
+describe("resolveTelegramAllowedEmojiReactions", () => {
+  it("uses getChat lookup when message chat does not include available_reactions", async () => {
+    const getChat: TelegramGetChat = async () => ({
+      available_reactions: [{ type: "emoji", emoji: "👍" }],
+    });
+
+    const result = await resolveTelegramAllowedEmojiReactions({
+      chat: { id: 1 } satisfies TelegramChatDetails,
+      chatId: 1,
+      getChat,
+    });
+
+    expect(result ? Array.from(result) : null).toEqual(["👍"]);
+  });
+
+  it("falls back to unrestricted reactions when getChat lookup fails", async () => {
+    const getChat = async () => {
+      throw new Error("lookup failed");
+    };
+
+    const result = await resolveTelegramAllowedEmojiReactions({
+      chat: { id: 1 } satisfies TelegramChatDetails,
+      chatId: 1,
+      getChat,
+    });
+
+    expect(result).toBeNull();
+  });
+});
+
+describe("resolveTelegramReactionVariant", () => {
+  it("returns requested emoji when already Telegram-supported", () => {
+    const variantsByEmoji = buildTelegramStatusReactionVariants({
+      ...DEFAULT_EMOJIS,
+      coding: "👨‍💻",
+    });
+
+    const result = resolveTelegramReactionVariant({
+      requestedEmoji: "👨‍💻",
+      variantsByRequestedEmoji: variantsByEmoji,
+    });
+
+    expect(result).toBe("👨‍💻");
+  });
+
+  it("returns first Telegram-supported fallback for unsupported requested emoji", () => {
+    const variantsByEmoji = buildTelegramStatusReactionVariants({
+      ...DEFAULT_EMOJIS,
+      coding: "🛠️",
+    });
+
+    const result = resolveTelegramReactionVariant({
+      requestedEmoji: "🛠️",
+      variantsByRequestedEmoji: variantsByEmoji,
+    });
+
+    expect(result).toBe("👨‍💻");
+  });
+
+  it("uses generic Telegram fallbacks for unknown emojis", () => {
+    const result = resolveTelegramReactionVariant({
+      requestedEmoji: "🫠",
+      variantsByRequestedEmoji: new Map(),
+    });
+
+    expect(result).toBe("👍");
+  });
+
+  it("respects chat allowed reactions", () => {
+    const variantsByEmoji = buildTelegramStatusReactionVariants({
+      ...DEFAULT_EMOJIS,
+      coding: "👨‍💻",
+    });
+
+    const result = resolveTelegramReactionVariant({
+      requestedEmoji: "👨‍💻",
+      variantsByRequestedEmoji: variantsByEmoji,
+      allowedEmojiReactions: new Set(["👍"]),
+    });
+
+    expect(result).toBe("👍");
+  });
+
+  it("returns undefined when no candidate is chat-allowed", () => {
+    const variantsByEmoji = buildTelegramStatusReactionVariants({
+      ...DEFAULT_EMOJIS,
+      coding: "👨‍💻",
+    });
+
+    const result = resolveTelegramReactionVariant({
+      requestedEmoji: "👨‍💻",
+      variantsByRequestedEmoji: variantsByEmoji,
+      allowedEmojiReactions: new Set(["🎉"]),
+    });
+
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined for empty requested emoji", () => {
+    const result = resolveTelegramReactionVariant({
+      requestedEmoji: "   ",
+      variantsByRequestedEmoji: new Map(),
+    });
+
+    expect(result).toBeUndefined();
+  });
+});