paperclip-plugin-telegram 0.2.0 → 0.2.2

package/tests/formatters.test.ts

@@ -1,185 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  formatIssueCreated,
-  formatIssueDone,
-  formatApprovalCreated,
-  formatAgentError,
-  formatAgentRunStarted,
-  formatAgentRunFinished,
-} from "../src/formatters.js";
-import type { PluginEvent } from "@paperclipai/plugin-sdk";
-
-function mockEvent(overrides: Record<string, unknown> = {}): PluginEvent {
-  return {
-    eventType: "issue.created",
-    entityId: "iss-123",
-    entityType: "issue",
-    companyId: "co-1",
-    occurredAt: new Date().toISOString(),
-    payload: { identifier: "PROJ-42", title: "Test issue", ...overrides },
-  } as PluginEvent;
-}
-
-describe("formatIssueCreated", () => {
-  it("includes identifier and title", () => {
-    const msg = formatIssueCreated(mockEvent());
-    expect(msg.text).toContain("PROJ\\-42");
-    expect(msg.text).toContain("Test issue");
-  });
-
-  it("falls back to entityId when no identifier", () => {
-    const msg = formatIssueCreated(mockEvent({ identifier: undefined }));
-    expect(msg.text).toContain("iss\\-123");
-  });
-
-  it("uses MarkdownV2 parse mode", () => {
-    const msg = formatIssueCreated(mockEvent());
-    expect(msg.options.parseMode).toBe("MarkdownV2");
-  });
-
-  it("includes metadata fields when available", () => {
-    const msg = formatIssueCreated(mockEvent({
-      status: "open",
-      priority: "high",
-      assigneeName: "Alice",
-      projectName: "Backend",
-    }));
-    expect(msg.text).toContain("open");
-    expect(msg.text).toContain("high");
-    expect(msg.text).toContain("Alice");
-    expect(msg.text).toContain("Backend");
-  });
-
-  it("includes description snippet", () => {
-    const msg = formatIssueCreated(mockEvent({ description: "A long description about this issue" }));
-    expect(msg.text).toContain("A long description");
-  });
-
-  it("truncates long descriptions at word boundary", () => {
-    const words = Array(50).fill("word").join(" ");
-    const msg = formatIssueCreated(mockEvent({ description: words }));
-    expect(msg.text).toContain("\\.\\.\\.");
-    expect(msg.text.length).toBeLessThan(words.length * 2);
-  });
-
-  it("omits metadata line when no metadata", () => {
-    const msg = formatIssueCreated(mockEvent({
-      status: undefined,
-      priority: undefined,
-      assigneeName: undefined,
-      projectName: undefined,
-    }));
-    expect(msg.text).not.toContain("\\|");
-  });
-});
-
-describe("formatIssueDone", () => {
-  it("includes identifier and done text", () => {
-    const msg = formatIssueDone(mockEvent());
-    expect(msg.text).toContain("PROJ\\-42");
-    expect(msg.text).toContain("done");
-  });
-
-  it("falls back to entityId", () => {
-    const msg = formatIssueDone(mockEvent({ identifier: undefined }));
-    expect(msg.text).toContain("iss\\-123");
-  });
-});
-
-describe("formatApprovalCreated", () => {
-  it("includes approve and reject buttons", () => {
-    const msg = formatApprovalCreated(mockEvent({
-      type: "deploy",
-      approvalId: "apr-1",
-      title: "Deploy to prod",
-    }));
-    expect(msg.options.inlineKeyboard).toBeDefined();
-    const buttons = msg.options.inlineKeyboard![0];
-    expect(buttons.length).toBe(2);
-    expect(buttons[0].text).toBe("Approve");
-    expect(buttons[0].callback_data).toBe("approve_apr-1");
-    expect(buttons[1].text).toBe("Reject");
-    expect(buttons[1].callback_data).toBe("reject_apr-1");
-  });
-
-  it("falls back to entityId for approvalId", () => {
-    const msg = formatApprovalCreated(mockEvent({ approvalId: undefined }));
-    const buttons = msg.options.inlineKeyboard![0];
-    expect(buttons[0].callback_data).toBe("approve_iss-123");
-  });
-
-  it("includes agent name when provided", () => {
-    const msg = formatApprovalCreated(mockEvent({
-      agentName: "Builder",
-      type: "deploy",
-    }));
-    expect(msg.text).toContain("Builder");
-  });
-
-  it("includes linked issues", () => {
-    const msg = formatApprovalCreated(mockEvent({
-      linkedIssues: [
-        { identifier: "ISS-1", title: "First", status: "open" },
-        { identifier: "ISS-2", title: "Second", status: "done" },
-      ],
-    }));
-    expect(msg.text).toContain("ISS\\-1");
-    expect(msg.text).toContain("ISS\\-2");
-    expect(msg.text).toContain("Linked Issues");
-  });
-
-  it("truncates description at word boundary", () => {
-    const longDesc = Array(80).fill("word").join(" ");
-    const msg = formatApprovalCreated(mockEvent({ description: longDesc }));
-    expect(msg.text).toContain("\\.\\.\\.");
-  });
-});
-
-describe("formatAgentError", () => {
-  it("includes agent name and error", () => {
-    const msg = formatAgentError(mockEvent({
-      agentName: "Builder",
-      error: "Connection refused",
-    }));
-    expect(msg.text).toContain("Builder");
-    expect(msg.text).toContain("Connection refused");
-  });
-
-  it("truncates long error messages", () => {
-    const longError = "x".repeat(600);
-    const msg = formatAgentError(mockEvent({ error: longError }));
-    expect(msg.text).toContain("\\.\\.\\.");
-    expect(msg.text).not.toContain("x".repeat(501));
-  });
-
-  it("falls back to entityId for agent name", () => {
-    const msg = formatAgentError(mockEvent({ agentName: undefined, name: undefined }));
-    expect(msg.text).toContain("iss\\-123");
-  });
-});
-
-describe("formatAgentRunStarted", () => {
-  it("includes agent name", () => {
-    const msg = formatAgentRunStarted(mockEvent({ agentName: "Deployer" }));
-    expect(msg.text).toContain("Deployer");
-    expect(msg.text).toContain("started");
-  });
-
-  it("disables notification", () => {
-    const msg = formatAgentRunStarted(mockEvent());
-    expect(msg.options.disableNotification).toBe(true);
-  });
-});
-
-describe("formatAgentRunFinished", () => {
-  it("includes agent name and completion text", () => {
-    const msg = formatAgentRunFinished(mockEvent({ agentName: "Deployer" }));
-    expect(msg.text).toContain("Deployer");
-    expect(msg.text).toContain("completed");
-  });
-
-  it("disables notification", () => {
-    const msg = formatAgentRunFinished(mockEvent());
-    expect(msg.options.disableNotification).toBe(true);
-  });
-});

package/tests/media-pipeline.test.ts

@@ -1,324 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { handleMediaMessage } from "../src/media-pipeline.js";
-import type { PluginContext } from "@paperclipai/plugin-sdk";
-
-let sentMessages: Array<{ chatId: string; text: string; options?: Record<string, unknown> }> = [];
-let stateStore: Record<string, unknown> = {};
-let emittedEvents: Array<{ event: string; companyId: string; payload: unknown }> = [];
-
-vi.mock("../src/telegram-api.js", async () => {
-  const actual = await vi.importActual("../src/telegram-api.js") as Record<string, unknown>;
-  return {
-    ...actual,
-    sendMessage: vi.fn(async (_ctx: unknown, _token: string, chatId: string, text: string, options?: Record<string, unknown>) => {
-      sentMessages.push({ chatId, text, options });
-      return 1;
-    }),
-    sendChatAction: vi.fn(),
-  };
-});
-
-vi.mock("../src/acp-bridge.js", async () => {
-  return {
-    getSessions: vi.fn(async (_ctx: unknown, _chatId: string, _threadId: number) => {
-      const key = `sessions_${_chatId}_${_threadId}`;
-      return (stateStore[key] as unknown[]) ?? [];
-    }),
-  };
-});
-
-function mockCtx(): PluginContext {
-  return {
-    http: {
-      fetch: vi.fn().mockResolvedValue({
-        json: () => Promise.resolve({
-          ok: true,
-          result: { file_path: "voice/file_0.oga" },
-        }),
-        blob: () => Promise.resolve(new Blob(["audio"])),
-      }),
-    },
-    metrics: { write: vi.fn() },
-    state: {
-      get: vi.fn(async (key: { stateKey: string }) => stateStore[key.stateKey] ?? null),
-      set: vi.fn(async (key: { stateKey: string }, value: unknown) => {
-        stateStore[key.stateKey] = value;
-      }),
-    },
-    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    events: {
-      emit: vi.fn((event: string, companyId: string, payload: unknown) => {
-        emittedEvents.push({ event, companyId, payload });
-      }),
-    },
-    agents: {
-      invoke: vi.fn().mockResolvedValue({ runId: "run-1" }),
-      sessions: {
-        sendMessage: vi.fn(),
-      },
-    },
-    secrets: {
-      resolve: vi.fn().mockResolvedValue("sk-test-key"),
-    },
-  } as unknown as PluginContext;
-}
-
-const defaultConfig = {
-  briefAgentId: "brief-agent",
-  briefAgentChatIds: ["intake-chat"],
-  transcriptionApiKeyRef: "openai-key",
-};
-
-beforeEach(() => {
-  sentMessages = [];
-  stateStore = {};
-  emittedEvents = [];
-});
-
-describe("Intake detection", () => {
-  it("processes media in intake channel", async () => {
-    const ctx = mockCtx();
-    const result = await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: Number("intake-chat") || 123 },
-      voice: { file_id: "voice-1", duration: 5 },
-      from: { id: 1, username: "user1" },
-    }, {
-      ...defaultConfig,
-      briefAgentChatIds: ["123"],
-    }, "company-1");
-
-    // Chat id "123" is in briefAgentChatIds -> intake channel
-    expect(result).toBe(true);
-  });
-
-  it("skips media not in intake channel and not in agent thread", async () => {
-    const ctx = mockCtx();
-    const result = await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 999 },
-      voice: { file_id: "voice-1", duration: 5 },
-    }, defaultConfig, "company-1");
-
-    expect(result).toBe(false);
-  });
-
-  it("processes media in agent thread with active session", async () => {
-    stateStore["sessions_456_42"] = [{
-      sessionId: "s1",
-      agentId: "a1",
-      agentName: "builder",
-      agentDisplayName: "Builder",
-      transport: "acp",
-      spawnedAt: "2026-01-01T00:00:00Z",
-      status: "active",
-      lastActivityAt: "2026-01-01T00:00:00Z",
-    }];
-
-    const ctx = mockCtx();
-    const result = await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 456 },
-      message_thread_id: 42,
-      document: { file_id: "doc-1", file_name: "report.pdf", mime_type: "application/pdf" },
-    }, { ...defaultConfig, briefAgentChatIds: [] }, "company-1");
-
-    expect(result).toBe(true);
-  });
-
-  it("skips media in thread without active session", async () => {
-    stateStore["sessions_456_42"] = [{
-      sessionId: "s1",
-      agentId: "a1",
-      agentName: "builder",
-      agentDisplayName: "Builder",
-      transport: "acp",
-      spawnedAt: "2026-01-01T00:00:00Z",
-      status: "closed",
-      lastActivityAt: "2026-01-01T00:00:00Z",
-    }];
-
-    const ctx = mockCtx();
-    const result = await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 456 },
-      message_thread_id: 42,
-      voice: { file_id: "voice-1", duration: 5 },
-    }, { ...defaultConfig, briefAgentChatIds: [] }, "company-1");
-
-    expect(result).toBe(false);
-  });
-});
-
-describe("Audio type detection", () => {
-  it("detects voice messages as audio", async () => {
-    const ctx = mockCtx();
-    // Mock the Whisper API response
-    (ctx.http.fetch as ReturnType<typeof vi.fn>).mockImplementation(async (url: string) => {
-      if (String(url).includes("openai.com")) {
-        return { json: () => Promise.resolve({ text: "Transcribed voice" }) };
-      }
-      if (String(url).includes("getFile")) {
-        return { json: () => Promise.resolve({ ok: true, result: { file_path: "voice/file.oga" } }) };
-      }
-      return { blob: () => Promise.resolve(new Blob(["data"])) };
-    });
-
-    await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 123 },
-      voice: { file_id: "voice-1", duration: 5, mime_type: "audio/ogg" },
-      from: { id: 1, username: "user1" },
-    }, { ...defaultConfig, briefAgentChatIds: ["123"] }, "company-1");
-
-    // Should show transcription preview
-    expect(sentMessages.some(m => m.text.includes("Transcription"))).toBe(true);
-  });
-
-  it("detects audio messages as audio", async () => {
-    const ctx = mockCtx();
-    (ctx.http.fetch as ReturnType<typeof vi.fn>).mockImplementation(async (url: string) => {
-      if (String(url).includes("openai.com")) {
-        return { json: () => Promise.resolve({ text: "Transcribed audio" }) };
-      }
-      if (String(url).includes("getFile")) {
-        return { json: () => Promise.resolve({ ok: true, result: { file_path: "audio/file.mp3" } }) };
-      }
-      return { blob: () => Promise.resolve(new Blob(["data"])) };
-    });
-
-    await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 123 },
-      audio: { file_id: "audio-1", duration: 120, title: "Song", mime_type: "audio/mpeg" },
-      from: { id: 1, username: "user1" },
-    }, { ...defaultConfig, briefAgentChatIds: ["123"] }, "company-1");
-
-    expect(sentMessages.some(m => m.text.includes("Transcription"))).toBe(true);
-  });
-
-  it("detects video_note as audio (transcribable)", async () => {
-    const ctx = mockCtx();
-    (ctx.http.fetch as ReturnType<typeof vi.fn>).mockImplementation(async (url: string) => {
-      if (String(url).includes("openai.com")) {
-        return { json: () => Promise.resolve({ text: "Video note text" }) };
-      }
-      if (String(url).includes("getFile")) {
-        return { json: () => Promise.resolve({ ok: true, result: { file_path: "videonote/file.mp4" } }) };
-      }
-      return { blob: () => Promise.resolve(new Blob(["data"])) };
-    });
-
-    await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 123 },
-      video_note: { file_id: "vn-1", duration: 10 },
-      from: { id: 1, username: "user1" },
-    }, { ...defaultConfig, briefAgentChatIds: ["123"] }, "company-1");
-
-    expect(sentMessages.some(m => m.text.includes("Transcription"))).toBe(true);
-  });
-
-  it("does not transcribe photo messages", async () => {
-    const ctx = mockCtx();
-    await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 123 },
-      photo: [{ file_id: "photo-1", width: 800, height: 600 }],
-      caption: "A nice photo",
-      from: { id: 1, username: "user1" },
-    }, { ...defaultConfig, briefAgentChatIds: ["123"] }, "company-1");
-
-    // Should not show transcription, but should still process
-    expect(sentMessages.every(m => !m.text.includes("Transcription"))).toBe(true);
-  });
-
-  it("does not transcribe document messages", async () => {
-    const ctx = mockCtx();
-    await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 123 },
-      document: { file_id: "doc-1", file_name: "file.pdf", mime_type: "application/pdf" },
-      from: { id: 1, username: "user1" },
-    }, { ...defaultConfig, briefAgentChatIds: ["123"] }, "company-1");
-
-    expect(sentMessages.every(m => !m.text.includes("Transcription"))).toBe(true);
-  });
-});
-
-describe("Media routing to agents in threads", () => {
-  it("routes media to most recently active agent in thread", async () => {
-    stateStore["sessions_456_42"] = [
-      {
-        sessionId: "s1",
-        agentId: "a1",
-        agentName: "builder",
-        agentDisplayName: "Builder",
-        transport: "acp",
-        spawnedAt: "2026-01-01T00:00:00Z",
-        status: "active",
-        lastActivityAt: "2026-01-01T00:00:00Z",
-      },
-      {
-        sessionId: "s2",
-        agentId: "a2",
-        agentName: "tester",
-        agentDisplayName: "Tester",
-        transport: "acp",
-        spawnedAt: "2026-01-01T00:00:00Z",
-        status: "active",
-        lastActivityAt: "2026-01-02T00:00:00Z", // more recent
-      },
-    ];
-
-    const ctx = mockCtx();
-    await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 456 },
-      message_thread_id: 42,
-      document: { file_id: "doc-1", file_name: "file.txt", mime_type: "text/plain" },
-      caption: "Check this",
-    }, { ...defaultConfig, briefAgentChatIds: [] }, "company-1");
-
-    // Should emit ACP event to the most recently active agent (s2)
-    const acp = emittedEvents.find(e => e.event === "acp-spawn");
-    expect(acp).toBeDefined();
-    expect((acp!.payload as Record<string, unknown>).sessionId).toBe("s2");
-  });
-
-  it("sends to native session when transport is native", async () => {
-    stateStore["sessions_456_42"] = [{
-      sessionId: "s1",
-      agentId: "a1",
-      agentName: "builder",
-      agentDisplayName: "Builder",
-      transport: "native",
-      spawnedAt: "2026-01-01T00:00:00Z",
-      status: "active",
-      lastActivityAt: "2026-01-01T00:00:00Z",
-    }];
-
-    const ctx = mockCtx();
-    await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 456 },
-      message_thread_id: 42,
-      document: { file_id: "doc-1", file_name: "file.txt" },
-    }, { ...defaultConfig, briefAgentChatIds: [] }, "company-1");
-
-    expect(ctx.agents.sessions.sendMessage).toHaveBeenCalled();
-  });
-});
-
-describe("Returns false for empty media", () => {
-  it("returns false when no file can be extracted", async () => {
-    const ctx = mockCtx();
-    const result = await handleMediaMessage(ctx, "token", {
-      message_id: 1,
-      chat: { id: 123 },
-      // no voice, audio, video_note, document, or photo
-    }, { ...defaultConfig, briefAgentChatIds: ["123"] }, "company-1");
-
-    expect(result).toBe(false);
-  });
-});

package/tests/telegram-api.test.ts

@@ -1,108 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { escapeMarkdownV2, truncateAtWord } from "../src/telegram-api.js";
-
-describe("escapeMarkdownV2", () => {
-  it("escapes underscores", () => {
-    expect(escapeMarkdownV2("hello_world")).toBe("hello\\_world");
-  });
-
-  it("escapes asterisks", () => {
-    expect(escapeMarkdownV2("*bold*")).toBe("\\*bold\\*");
-  });
-
-  it("escapes brackets", () => {
-    expect(escapeMarkdownV2("[link](url)")).toBe("\\[link\\]\\(url\\)");
-  });
-
-  it("escapes backticks", () => {
-    expect(escapeMarkdownV2("`code`")).toBe("\\`code\\`");
-  });
-
-  it("escapes tildes", () => {
-    expect(escapeMarkdownV2("~strikethrough~")).toBe("\\~strikethrough\\~");
-  });
-
-  it("escapes hashes", () => {
-    expect(escapeMarkdownV2("#heading")).toBe("\\#heading");
-  });
-
-  it("escapes plus signs", () => {
-    expect(escapeMarkdownV2("a+b")).toBe("a\\+b");
-  });
-
-  it("escapes hyphens", () => {
-    expect(escapeMarkdownV2("a-b")).toBe("a\\-b");
-  });
-
-  it("escapes equal signs", () => {
-    expect(escapeMarkdownV2("a=b")).toBe("a\\=b");
-  });
-
-  it("escapes pipes", () => {
-    expect(escapeMarkdownV2("a|b")).toBe("a\\|b");
-  });
-
-  it("escapes curly braces", () => {
-    expect(escapeMarkdownV2("{a}")).toBe("\\{a\\}");
-  });
-
-  it("escapes dots", () => {
-    expect(escapeMarkdownV2("a.b")).toBe("a\\.b");
-  });
-
-  it("escapes exclamation marks", () => {
-    expect(escapeMarkdownV2("hello!")).toBe("hello\\!");
-  });
-
-  it("escapes backslashes", () => {
-    expect(escapeMarkdownV2("a\\b")).toBe("a\\\\b");
-  });
-
-  it("escapes greater than", () => {
-    expect(escapeMarkdownV2("a>b")).toBe("a\\>b");
-  });
-
-  it("handles multiple special chars in one string", () => {
-    expect(escapeMarkdownV2("PROJ-42: Fix [bug] #1"))
-      .toBe("PROJ\\-42: Fix \\[bug\\] \\#1");
-  });
-
-  it("leaves plain text unchanged", () => {
-    expect(escapeMarkdownV2("hello world")).toBe("hello world");
-  });
-
-  it("handles empty string", () => {
-    expect(escapeMarkdownV2("")).toBe("");
-  });
-});
-
-describe("truncateAtWord", () => {
-  it("returns text unchanged if shorter than max", () => {
-    expect(truncateAtWord("hello", 10)).toBe("hello");
-  });
-
-  it("returns text unchanged if equal to max", () => {
-    expect(truncateAtWord("hello", 5)).toBe("hello");
-  });
-
-  it("truncates at word boundary and adds ellipsis", () => {
-    const result = truncateAtWord("hello world foo bar baz", 15);
-    expect(result).toBe("hello world...");
-  });
-
-  it("falls back to hard cut when no good word boundary", () => {
-    const result = truncateAtWord("abcdefghijklmnopqrstuvwxyz", 10);
-    expect(result).toBe("abcdefghij...");
-    expect(result.length).toBe(13);
-  });
-
-  it("handles single word longer than max", () => {
-    const result = truncateAtWord("superlongword", 5);
-    expect(result).toBe("super...");
-  });
-
-  it("handles text with trailing space at boundary", () => {
-    const result = truncateAtWord("aa bb cc dd ee ff", 8);
-    expect(result).toBe("aa bb cc...");
-  });
-});