@llblab/pi-telegram 0.2.10 → 0.4.0

package/tests/attachments.test.ts

@@ -1,132 +0,0 @@
-/**
- * Regression tests for the Telegram attachments domain
- * Covers attachment queueing and attachment delivery behavior in one domain-level suite
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  queueTelegramAttachments,
-  sendQueuedTelegramAttachments,
-} from "../lib/attachments.ts";
-
-test("Attachment queueing adds files to the active Telegram turn", async () => {
-  const activeTurn = {
-    queuedAttachments: [],
-  } as unknown as {
-    queuedAttachments: Array<{ path: string; fileName: string }>;
-  } & Parameters<typeof queueTelegramAttachments>[0]["activeTurn"];
-  const result = await queueTelegramAttachments({
-    activeTurn,
-    paths: ["/tmp/demo.txt"],
-    maxAttachmentsPerTurn: 2,
-    statPath: async () => ({ isFile: () => true }),
-  });
-  assert.deepEqual(activeTurn.queuedAttachments, [
-    { path: "/tmp/demo.txt", fileName: "demo.txt" },
-  ]);
-  assert.deepEqual(result.details.paths, ["/tmp/demo.txt"]);
-});
-
-test("Attachment queueing rejects missing turns, non-files, and full queues", async () => {
-  await assert.rejects(
-    () =>
-      queueTelegramAttachments({
-        activeTurn: undefined,
-        paths: ["/tmp/demo.txt"],
-        maxAttachmentsPerTurn: 1,
-        statPath: async () => ({ isFile: () => true }),
-      }),
-    { message: /active Telegram turn/ },
-  );
-  await assert.rejects(
-    () =>
-      queueTelegramAttachments({
-        activeTurn: { queuedAttachments: [] } as never,
-        paths: ["/tmp/demo.txt"],
-        maxAttachmentsPerTurn: 1,
-        statPath: async () => ({ isFile: () => false }),
-      }),
-    { message: "Not a file: /tmp/demo.txt" },
-  );
-  await assert.rejects(
-    () =>
-      queueTelegramAttachments({
-        activeTurn: {
-          queuedAttachments: [{ path: "/tmp/a.txt", fileName: "a.txt" }],
-        } as never,
-        paths: ["/tmp/demo.txt"],
-        maxAttachmentsPerTurn: 1,
-        statPath: async () => ({ isFile: () => true }),
-      }),
-    { message: "Attachment limit reached (1)" },
-  );
-});
-
-test("Attachment delivery chooses photo vs document methods from file paths", async () => {
-  const sent: Array<string> = [];
-  await sendQueuedTelegramAttachments(
-    {
-      kind: "prompt",
-      chatId: 1,
-      replyToMessageId: 2,
-      sourceMessageIds: [],
-      queueOrder: 1,
-      queueLane: "default",
-      laneOrder: 1,
-      queuedAttachments: [
-        { path: "/tmp/a.png", fileName: "a.png" },
-        { path: "/tmp/b.txt", fileName: "b.txt" },
-      ],
-      content: [{ type: "text", text: "prompt" }],
-      historyText: "history",
-      statusSummary: "summary",
-    },
-    {
-      sendMultipart: async (
-        method,
-        _fields,
-        fileField,
-        _filePath,
-        fileName,
-      ) => {
-        sent.push(`${method}:${fileField}:${fileName}`);
-      },
-      sendTextReply: async () => undefined,
-    },
-  );
-  assert.deepEqual(sent, [
-    "sendPhoto:photo:a.png",
-    "sendDocument:document:b.txt",
-  ]);
-});
-
-test("Attachment delivery reports per-file failures via text replies", async () => {
-  const replies: string[] = [];
-  await sendQueuedTelegramAttachments(
-    {
-      kind: "prompt",
-      chatId: 1,
-      replyToMessageId: 2,
-      sourceMessageIds: [],
-      queueOrder: 1,
-      queueLane: "default",
-      laneOrder: 1,
-      queuedAttachments: [{ path: "/tmp/a.png", fileName: "a.png" }],
-      content: [{ type: "text", text: "prompt" }],
-      historyText: "history",
-      statusSummary: "summary",
-    },
-    {
-      sendMultipart: async () => {
-        throw new Error("upload failed");
-      },
-      sendTextReply: async (_chatId, _replyToMessageId, text) => {
-        replies.push(text);
-        return undefined;
-      },
-    },
-  );
-  assert.deepEqual(replies, ["Failed to send attachment a.png: upload failed"]);
-});

package/tests/commands.test.ts

@@ -1,85 +0,0 @@
-/**
- * Regression tests for Telegram command helpers
- * Covers slash-command normalization, bot suffix stripping, arguments, and non-command input
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  buildTelegramCommandAction,
-  executeTelegramCommandAction,
-  parseTelegramCommand,
-} from "../lib/commands.ts";
-
-test("Command helpers parse slash commands with args", () => {
-  assert.deepEqual(parseTelegramCommand(" /Model@DemoBot  claude opus "), {
-    name: "model",
-    args: "claude opus",
-  });
-  assert.deepEqual(parseTelegramCommand("/status"), {
-    name: "status",
-    args: "",
-  });
-});
-
-test("Command helpers ignore non-command input and empty names", () => {
-  assert.equal(parseTelegramCommand("hello /status"), undefined);
-  assert.equal(parseTelegramCommand("/"), undefined);
-});
-
-test("Command helpers build command actions", () => {
-  assert.deepEqual(buildTelegramCommandAction("stop"), { kind: "stop" });
-  assert.deepEqual(buildTelegramCommandAction("compact"), { kind: "compact" });
-  assert.deepEqual(buildTelegramCommandAction("status"), { kind: "status" });
-  assert.deepEqual(buildTelegramCommandAction("model"), { kind: "model" });
-  assert.deepEqual(buildTelegramCommandAction("help"), {
-    kind: "help",
-    commandName: "help",
-  });
-  assert.deepEqual(buildTelegramCommandAction("start"), {
-    kind: "help",
-    commandName: "start",
-  });
-  assert.deepEqual(buildTelegramCommandAction("unknown"), { kind: "ignore" });
-  assert.deepEqual(buildTelegramCommandAction(undefined), { kind: "ignore" });
-});
-
-test("Command helpers execute command actions through provided handlers", async () => {
-  const events: string[] = [];
-  const deps = {
-    handleStop: async () => {
-      events.push("stop");
-    },
-    handleCompact: async () => {
-      events.push("compact");
-    },
-    handleStatus: async () => {
-      events.push("status");
-    },
-    handleModel: async () => {
-      events.push("model");
-    },
-    handleHelp: async (_message: unknown, commandName: "help" | "start") => {
-      events.push(`help:${commandName}`);
-    },
-  };
-  assert.equal(
-    await executeTelegramCommandAction({ kind: "ignore" }, {}, {}, deps),
-    false,
-  );
-  assert.equal(
-    await executeTelegramCommandAction({ kind: "stop" }, {}, {}, deps),
-    true,
-  );
-  assert.equal(
-    await executeTelegramCommandAction(
-      { kind: "help", commandName: "start" },
-      {},
-      {},
-      deps,
-    ),
-    true,
-  );
-  assert.deepEqual(events, ["stop", "help:start"]);
-});

package/tests/config.test.ts

@@ -1,80 +0,0 @@
-/**
- * Regression tests for Telegram setup prompt defaults
- * Covers token-prefill priority across stored config, environment variables, and placeholder fallback
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { __telegramTestUtils } from "../index.ts";
-
-test("Bot token input prefers stored config over env vars", () => {
-  const value = __telegramTestUtils.getTelegramBotTokenInputDefault(
-    {
-      TELEGRAM_KEY: "key-last",
-      TELEGRAM_TOKEN: "token-third",
-      TELEGRAM_BOT_KEY: "key-second",
-      TELEGRAM_BOT_TOKEN: "token-first",
-    },
-    "stored-token",
-  );
-  assert.equal(value, "stored-token");
-});
-
-test("Bot token input prefers the first configured Telegram env var when no config exists", () => {
-  const value = __telegramTestUtils.getTelegramBotTokenInputDefault({
-    TELEGRAM_KEY: "key-last",
-    TELEGRAM_TOKEN: "token-third",
-    TELEGRAM_BOT_KEY: "key-second",
-    TELEGRAM_BOT_TOKEN: "token-first",
-  });
-  assert.equal(value, "token-first");
-});
-
-test("Bot token prompt uses the editor when a real prefill exists", () => {
-  const prompt = __telegramTestUtils.getTelegramBotTokenPromptSpec({
-    TELEGRAM_BOT_TOKEN: "token-first",
-  });
-  assert.deepEqual(prompt, {
-    method: "editor",
-    value: "token-first",
-  });
-});
-
-test("Bot token prompt shows stored config before env values", () => {
-  const prompt = __telegramTestUtils.getTelegramBotTokenPromptSpec(
-    {
-      TELEGRAM_BOT_TOKEN: "token-first",
-    },
-    "stored-token",
-  );
-  assert.deepEqual(prompt, {
-    method: "editor",
-    value: "stored-token",
-  });
-});
-
-test("Bot token input skips blank env vars and falls back to config", () => {
-  const value = __telegramTestUtils.getTelegramBotTokenInputDefault(
-    {
-      TELEGRAM_BOT_TOKEN: "   ",
-      TELEGRAM_BOT_KEY: "",
-      TELEGRAM_TOKEN: "  ",
-    },
-    "stored-token",
-  );
-  assert.equal(value, "stored-token");
-});
-
-test("Bot token input falls back to placeholder when no value exists", () => {
-  const value = __telegramTestUtils.getTelegramBotTokenInputDefault({});
-  assert.equal(value, "123456:ABCDEF...");
-});
-
-test("Bot token prompt uses placeholder input when no prefill exists", () => {
-  const prompt = __telegramTestUtils.getTelegramBotTokenPromptSpec({});
-  assert.deepEqual(prompt, {
-    method: "input",
-    value: "123456:ABCDEF...",
-  });
-});

package/tests/media.test.ts

@@ -1,166 +0,0 @@
-/**
- * Regression tests for Telegram media and text extraction helpers
- * Covers inbound file-info collection, text extraction, media groups, id collection, and history formatting
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import {
-  collectTelegramFileInfos,
-  collectTelegramMessageIds,
-  extractFirstTelegramMessageText,
-  extractTelegramMessagesText,
-  formatTelegramHistoryText,
-  getTelegramMediaGroupKey,
-  guessMediaType,
-  queueTelegramMediaGroupMessage,
-  removePendingTelegramMediaGroupMessages,
-  type TelegramMediaGroupState,
-} from "../lib/media.ts";
-
-test("Media helpers collect file infos across Telegram message variants", () => {
-  const files = collectTelegramFileInfos([
-    {
-      message_id: 1,
-      text: "hello",
-      photo: [
-        { file_id: "small", file_size: 1 },
-        { file_id: "large", file_size: 10 },
-      ],
-      document: {
-        file_id: "doc",
-        file_name: "report.png",
-        mime_type: "image/png",
-      },
-      voice: {
-        file_id: "voice",
-        mime_type: "audio/ogg",
-      },
-      sticker: {
-        file_id: "sticker",
-      },
-    },
-  ]);
-  assert.deepEqual(
-    files.map((file) => ({
-      id: file.file_id,
-      name: file.fileName,
-      image: file.isImage,
-    })),
-    [
-      { id: "large", name: "photo-1.jpg", image: true },
-      { id: "doc", name: "report.png", image: true },
-      { id: "voice", name: "voice-1.ogg", image: false },
-      { id: "sticker", name: "sticker-1.webp", image: true },
-    ],
-  );
-});
-
-test("Media helpers extract text, ids, and history summaries", () => {
-  const messages = [
-    { message_id: 1, text: "first" },
-    { message_id: 2, caption: "second" },
-    { message_id: 2, text: "duplicate id" },
-  ];
-  assert.equal(
-    extractTelegramMessagesText(messages),
-    "first\n\nsecond\n\nduplicate id",
-  );
-  assert.equal(extractFirstTelegramMessageText(messages), "first");
-  assert.deepEqual(collectTelegramMessageIds(messages), [1, 2]);
-  assert.equal(
-    formatTelegramHistoryText("hello", [{ path: "/tmp/demo.txt" }]),
-    "hello\nAttachments:\n- /tmp/demo.txt",
-  );
-});
-
-test("Media helpers infer outgoing image media types from file paths", () => {
-  assert.equal(guessMediaType("/tmp/demo.png"), "image/png");
-  assert.equal(guessMediaType("/tmp/demo.txt"), undefined);
-});
-
-test("Media helpers key messages by chat and media group", () => {
-  assert.equal(
-    getTelegramMediaGroupKey({
-      message_id: 1,
-      chat: { id: 7 },
-      media_group_id: "album",
-    }),
-    "7:album",
-  );
-  assert.equal(
-    getTelegramMediaGroupKey({ message_id: 1, chat: { id: 7 } }),
-    undefined,
-  );
-});
-
-test("Media helpers replace debounce timers and dispatch grouped messages", () => {
-  const groups = new Map<
-    string,
-    TelegramMediaGroupState<{
-      message_id: number;
-      chat: { id: number };
-      media_group_id?: string;
-    }>
-  >();
-  const cleared: number[] = [];
-  const callbacks: Array<() => void> = [];
-  const dispatched: number[][] = [];
-  let nextTimer = 1;
-  const setTimer = (callback: () => void): ReturnType<typeof setTimeout> => {
-    callbacks.push(callback);
-    return nextTimer++ as unknown as ReturnType<typeof setTimeout>;
-  };
-  const clearTimer = (timer: ReturnType<typeof setTimeout>): void => {
-    cleared.push(timer as unknown as number);
-  };
-  assert.equal(
-    queueTelegramMediaGroupMessage({
-      message: { message_id: 1, chat: { id: 7 }, media_group_id: "album" },
-      groups,
-      debounceMs: 100,
-      setTimer,
-      clearTimer,
-      dispatchMessages: (messages) =>
-        dispatched.push(messages.map((message) => message.message_id)),
-    }),
-    true,
-  );
-  queueTelegramMediaGroupMessage({
-    message: { message_id: 2, chat: { id: 7 }, media_group_id: "album" },
-    groups,
-    debounceMs: 100,
-    setTimer,
-    clearTimer,
-    dispatchMessages: (messages) =>
-      dispatched.push(messages.map((message) => message.message_id)),
-  });
-  assert.deepEqual(cleared, [1]);
-  callbacks.at(-1)?.();
-  assert.deepEqual(dispatched, [[1, 2]]);
-  assert.equal(groups.size, 0);
-});
-
-test("Media helpers remove pending groups by message id", () => {
-  const groups = new Map<
-    string,
-    TelegramMediaGroupState<{ message_id: number; chat: { id: number } }>
-  >();
-  groups.set("7:album", {
-    messages: [
-      { message_id: 1, chat: { id: 7 } },
-      { message_id: 2, chat: { id: 7 } },
-    ],
-    flushTimer: 10 as unknown as ReturnType<typeof setTimeout>,
-  });
-  const cleared: number[] = [];
-  assert.equal(
-    removePendingTelegramMediaGroupMessages(groups, [2], (timer) => {
-      cleared.push(timer as unknown as number);
-    }),
-    1,
-  );
-  assert.deepEqual(cleared, [10]);
-  assert.equal(groups.size, 0);
-});