@openclaw/msteams 2026.5.2 → 2026.5.3-beta.2

package/src/graph-teams.test.ts

@@ -1,215 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { OpenClawConfig } from "../runtime-api.js";
-import { getChannelInfoMSTeams, listChannelsMSTeams } from "./graph-teams.js";
-
-const mockState = vi.hoisted(() => ({
-  resolveGraphToken: vi.fn(),
-  fetchGraphJson: vi.fn(),
-}));
-
-vi.mock("./graph.js", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("./graph.js")>();
-  return {
-    ...actual,
-    resolveGraphToken: mockState.resolveGraphToken,
-    fetchGraphJson: mockState.fetchGraphJson,
-  };
-});
-
-const TOKEN = "test-graph-token";
-
-describe("listChannelsMSTeams", () => {
-  beforeEach(() => {
-    mockState.resolveGraphToken.mockReset().mockResolvedValue(TOKEN);
-    mockState.fetchGraphJson.mockReset();
-  });
-
-  it("returns channels with all fields mapped", async () => {
-    mockState.fetchGraphJson.mockResolvedValue({
-      value: [
-        {
-          id: "ch-1",
-          displayName: "General",
-          description: "The default channel",
-          membershipType: "standard",
-        },
-        {
-          id: "ch-2",
-          displayName: "Engineering",
-          description: "Engineering discussions",
-          membershipType: "private",
-        },
-      ],
-    });
-
-    const result = await listChannelsMSTeams({
-      cfg: {} as OpenClawConfig,
-      teamId: "team-abc",
-    });
-
-    expect(result.channels).toEqual([
-      {
-        id: "ch-1",
-        displayName: "General",
-        description: "The default channel",
-        membershipType: "standard",
-      },
-      {
-        id: "ch-2",
-        displayName: "Engineering",
-        description: "Engineering discussions",
-        membershipType: "private",
-      },
-    ]);
-    expect(mockState.fetchGraphJson).toHaveBeenCalledWith({
-      token: TOKEN,
-      path: `/teams/${encodeURIComponent("team-abc")}/channels?$select=id,displayName,description,membershipType`,
-    });
-  });
-
-  it("returns empty array when team has no channels", async () => {
-    mockState.fetchGraphJson.mockResolvedValue({ value: [] });
-
-    const result = await listChannelsMSTeams({
-      cfg: {} as OpenClawConfig,
-      teamId: "team-empty",
-    });
-
-    expect(result.channels).toEqual([]);
-  });
-
-  it("returns empty array when value is undefined", async () => {
-    mockState.fetchGraphJson.mockResolvedValue({});
-
-    const result = await listChannelsMSTeams({
-      cfg: {} as OpenClawConfig,
-      teamId: "team-no-value",
-    });
-
-    expect(result.channels).toEqual([]);
-  });
-
-  it("follows @odata.nextLink across multiple pages", async () => {
-    mockState.fetchGraphJson
-      .mockResolvedValueOnce({
-        value: [
-          { id: "ch-1", displayName: "General", description: null, membershipType: "standard" },
-        ],
-        "@odata.nextLink":
-          "https://graph.microsoft.com/v1.0/teams/team-paged/channels?$select=id,displayName,description,membershipType&$skip=1",
-      })
-      .mockResolvedValueOnce({
-        value: [
-          { id: "ch-2", displayName: "Random", description: "Fun", membershipType: "standard" },
-        ],
-        "@odata.nextLink":
-          "https://graph.microsoft.com/v1.0/teams/team-paged/channels?$select=id,displayName,description,membershipType&$skip=2",
-      })
-      .mockResolvedValueOnce({
-        value: [
-          { id: "ch-3", displayName: "Private", description: null, membershipType: "private" },
-        ],
-      });
-
-    const result = await listChannelsMSTeams({
-      cfg: {} as OpenClawConfig,
-      teamId: "team-paged",
-    });
-
-    expect(result.channels).toHaveLength(3);
-    expect(result.channels.map((ch) => ch.id)).toEqual(["ch-1", "ch-2", "ch-3"]);
-    expect(result.truncated).toBe(false);
-    expect(mockState.fetchGraphJson).toHaveBeenCalledTimes(3);
-
-    // Second call should use the relative path stripped from the nextLink
-    const secondCallPath = mockState.fetchGraphJson.mock.calls[1]?.[0]?.path;
-    expect(secondCallPath).toBe(
-      "/teams/team-paged/channels?$select=id,displayName,description,membershipType&$skip=1",
-    );
-  });
-
-  it("stops after 10 pages to avoid runaway pagination", async () => {
-    for (let i = 0; i < 11; i++) {
-      mockState.fetchGraphJson.mockResolvedValueOnce({
-        value: [
-          {
-            id: `ch-${i}`,
-            displayName: `Channel ${i}`,
-            description: null,
-            membershipType: "standard",
-          },
-        ],
-        "@odata.nextLink": `https://graph.microsoft.com/v1.0/teams/team-huge/channels?$skip=${i + 1}`,
-      });
-    }
-
-    const result = await listChannelsMSTeams({
-      cfg: {} as OpenClawConfig,
-      teamId: "team-huge",
-    });
-
-    // Should stop at 10 pages even though more nextLinks are available
-    expect(result.channels).toHaveLength(10);
-    expect(mockState.fetchGraphJson).toHaveBeenCalledTimes(10);
-    expect(result.truncated).toBe(true);
-  });
-});
-
-describe("getChannelInfoMSTeams", () => {
-  beforeEach(() => {
-    mockState.resolveGraphToken.mockReset().mockResolvedValue(TOKEN);
-    mockState.fetchGraphJson.mockReset();
-  });
-
-  it("returns channel with all fields", async () => {
-    mockState.fetchGraphJson.mockResolvedValue({
-      id: "ch-1",
-      displayName: "General",
-      description: "The default channel",
-      membershipType: "standard",
-      webUrl: "https://teams.microsoft.com/l/channel/ch-1/General",
-      createdDateTime: "2026-01-15T09:00:00Z",
-    });
-
-    const result = await getChannelInfoMSTeams({
-      cfg: {} as OpenClawConfig,
-      teamId: "team-abc",
-      channelId: "ch-1",
-    });
-
-    expect(result.channel).toEqual({
-      id: "ch-1",
-      displayName: "General",
-      description: "The default channel",
-      membershipType: "standard",
-      webUrl: "https://teams.microsoft.com/l/channel/ch-1/General",
-      createdDateTime: "2026-01-15T09:00:00Z",
-    });
-    expect(mockState.fetchGraphJson).toHaveBeenCalledWith({
-      token: TOKEN,
-      path: `/teams/${encodeURIComponent("team-abc")}/channels/${encodeURIComponent("ch-1")}?$select=id,displayName,description,membershipType,webUrl,createdDateTime`,
-    });
-  });
-
-  it("handles missing optional fields gracefully", async () => {
-    mockState.fetchGraphJson.mockResolvedValue({
-      id: "ch-2",
-      displayName: "Private Channel",
-    });
-
-    const result = await getChannelInfoMSTeams({
-      cfg: {} as OpenClawConfig,
-      teamId: "team-abc",
-      channelId: "ch-2",
-    });
-
-    expect(result.channel).toEqual({
-      id: "ch-2",
-      displayName: "Private Channel",
-      description: undefined,
-      membershipType: undefined,
-      webUrl: undefined,
-      createdDateTime: undefined,
-    });
-  });
-});

package/src/graph-teams.ts

@@ -1,114 +0,0 @@
-import type { OpenClawConfig } from "../runtime-api.js";
-import { type GraphResponse, fetchGraphJson, resolveGraphToken } from "./graph.js";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-type GraphTeamsChannel = {
-  id?: string;
-  displayName?: string;
-  description?: string;
-  membershipType?: string;
-  webUrl?: string;
-  createdDateTime?: string;
-};
-
-type ListChannelsMSTeamsParams = {
-  cfg: OpenClawConfig;
-  teamId: string;
-};
-
-type ListChannelsMSTeamsResult = {
-  channels: Array<{
-    id: string | undefined;
-    displayName: string | undefined;
-    description: string | undefined;
-    membershipType: string | undefined;
-  }>;
-  truncated?: boolean;
-};
-
-type GetChannelInfoMSTeamsParams = {
-  cfg: OpenClawConfig;
-  teamId: string;
-  channelId: string;
-};
-
-type GetChannelInfoMSTeamsResult = {
-  channel: {
-    id: string | undefined;
-    displayName: string | undefined;
-    description: string | undefined;
-    membershipType: string | undefined;
-    webUrl: string | undefined;
-    createdDateTime: string | undefined;
-  };
-};
-
-// ---------------------------------------------------------------------------
-// List channels for a team
-// ---------------------------------------------------------------------------
-
-/**
- * List channels in a team via Graph API.
- * Returns id, displayName, description, and membershipType for each channel.
- * Follows @odata.nextLink for paginated results (up to 10 pages).
- */
-export async function listChannelsMSTeams(
-  params: ListChannelsMSTeamsParams,
-): Promise<ListChannelsMSTeamsResult> {
-  const token = await resolveGraphToken(params.cfg);
-  const firstPath = `/teams/${encodeURIComponent(params.teamId)}/channels?$select=id,displayName,description,membershipType`;
-  const collected: GraphTeamsChannel[] = [];
-  let nextPath: string | undefined = firstPath;
-  const MAX_PAGES = 10;
-  let page = 0;
-  while (nextPath && page < MAX_PAGES) {
-    type PagedChannelResponse = GraphResponse<GraphTeamsChannel> & {
-      "@odata.nextLink"?: string;
-    };
-    const res: PagedChannelResponse = await fetchGraphJson<PagedChannelResponse>({
-      token,
-      path: nextPath,
-    });
-    collected.push(...(res.value ?? []));
-    const nextLink: string | undefined = res["@odata.nextLink"];
-    // Strip the Graph API root so fetchGraphJson receives a relative path
-    nextPath = nextLink ? nextLink.replace("https://graph.microsoft.com/v1.0", "") : undefined;
-    page++;
-  }
-  const channels = collected.map((ch) => ({
-    id: ch.id,
-    displayName: ch.displayName,
-    description: ch.description,
-    membershipType: ch.membershipType,
-  }));
-  return { channels, truncated: !!nextPath };
-}
-
-// ---------------------------------------------------------------------------
-// Get channel info
-// ---------------------------------------------------------------------------
-
-/**
- * Get detailed information about a single channel in a team via Graph API.
- * Returns id, displayName, description, membershipType, webUrl, and createdDateTime.
- */
-export async function getChannelInfoMSTeams(
-  params: GetChannelInfoMSTeamsParams,
-): Promise<GetChannelInfoMSTeamsResult> {
-  const token = await resolveGraphToken(params.cfg);
-  const path = `/teams/${encodeURIComponent(params.teamId)}/channels/${encodeURIComponent(params.channelId)}?$select=id,displayName,description,membershipType,webUrl,createdDateTime`;
-  const ch = await fetchGraphJson<GraphTeamsChannel>({ token, path });
-  return {
-    channel: {
-      id: ch.id,
-      displayName: ch.displayName,
-      description: ch.description,
-      membershipType: ch.membershipType,
-      webUrl: ch.webUrl,
-      createdDateTime: ch.createdDateTime,
-    },
-  };
-}

package/src/graph-thread.test.ts

@@ -1,246 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  _teamGroupIdCacheForTest,
-  fetchChannelMessage,
-  fetchThreadReplies,
-  formatThreadContext,
-  resolveTeamGroupId,
-  stripHtmlFromTeamsMessage,
-} from "./graph-thread.js";
-import { fetchGraphJson } from "./graph.js";
-
-vi.mock("./graph.js", () => ({
-  fetchGraphJson: vi.fn(),
-}));
-
-describe("stripHtmlFromTeamsMessage", () => {
-  it("preserves @mention display names from <at> tags", () => {
-    expect(stripHtmlFromTeamsMessage("<at>Alice</at> hello")).toBe("@Alice hello");
-  });
-
-  it("strips other HTML tags", () => {
-    expect(stripHtmlFromTeamsMessage("<p>Hello <b>world</b></p>")).toBe("Hello world");
-  });
-
-  it("decodes common HTML entities", () => {
-    expect(stripHtmlFromTeamsMessage("&amp; &lt;b&gt; &quot;x&quot; &#39;y&#39; &nbsp;z")).toBe(
-      "& <b> \"x\" 'y' z",
-    );
-  });
-
-  it("normalizes multiple whitespace to single space", () => {
-    expect(stripHtmlFromTeamsMessage("hello   world")).toBe("hello world");
-  });
-
-  it("handles <at> tags with attributes", () => {
-    expect(stripHtmlFromTeamsMessage('<at id="123">Bob</at> please review')).toBe(
-      "@Bob please review",
-    );
-  });
-
-  it("returns empty string for empty input", () => {
-    expect(stripHtmlFromTeamsMessage("")).toBe("");
-  });
-});
-
-describe("resolveTeamGroupId", () => {
-  beforeEach(() => {
-    vi.mocked(fetchGraphJson).mockReset();
-    _teamGroupIdCacheForTest.clear();
-  });
-
-  it("fetches team id from Graph and caches it", async () => {
-    vi.mocked(fetchGraphJson).mockResolvedValueOnce({ id: "group-guid-1" } as never);
-
-    const result = await resolveTeamGroupId("tok", "team-123");
-    expect(result).toBe("group-guid-1");
-    expect(fetchGraphJson).toHaveBeenCalledWith({
-      token: "tok",
-      path: "/teams/team-123?$select=id",
-    });
-  });
-
-  it("returns cached value without calling Graph again", async () => {
-    vi.mocked(fetchGraphJson).mockResolvedValueOnce({ id: "group-guid-2" } as never);
-
-    await resolveTeamGroupId("tok", "team-456");
-    await resolveTeamGroupId("tok", "team-456");
-
-    expect(fetchGraphJson).toHaveBeenCalledTimes(1);
-  });
-
-  it("falls back to conversationTeamId when Graph returns no id", async () => {
-    vi.mocked(fetchGraphJson).mockResolvedValueOnce({} as never);
-
-    const result = await resolveTeamGroupId("tok", "team-fallback");
-    expect(result).toBe("team-fallback");
-  });
-});
-
-describe("fetchChannelMessage", () => {
-  beforeEach(() => {
-    vi.mocked(fetchGraphJson).mockReset();
-  });
-
-  it("fetches the parent message with correct path", async () => {
-    const mockMsg = { id: "msg-1", body: { content: "hello", contentType: "text" } };
-    vi.mocked(fetchGraphJson).mockResolvedValueOnce(mockMsg as never);
-
-    const result = await fetchChannelMessage("tok", "group-1", "channel-1", "msg-1");
-
-    expect(result).toEqual(mockMsg);
-    expect(fetchGraphJson).toHaveBeenCalledWith({
-      token: "tok",
-      path: "/teams/group-1/channels/channel-1/messages/msg-1?$select=id,from,body,createdDateTime",
-    });
-  });
-
-  it("returns undefined on fetch error", async () => {
-    vi.mocked(fetchGraphJson).mockRejectedValueOnce(new Error("forbidden") as never);
-
-    const result = await fetchChannelMessage("tok", "group-1", "channel-1", "msg-1");
-    expect(result).toBeUndefined();
-  });
-
-  it("URL-encodes group, channel, and message IDs", async () => {
-    vi.mocked(fetchGraphJson).mockResolvedValueOnce({} as never);
-
-    await fetchChannelMessage("tok", "g/1", "c/2", "m/3");
-
-    expect(fetchGraphJson).toHaveBeenCalledWith({
-      token: "tok",
-      path: "/teams/g%2F1/channels/c%2F2/messages/m%2F3?$select=id,from,body,createdDateTime",
-    });
-  });
-});
-
-describe("fetchThreadReplies", () => {
-  beforeEach(() => {
-    vi.mocked(fetchGraphJson).mockReset();
-  });
-
-  it("fetches replies with correct path and default limit", async () => {
-    vi.mocked(fetchGraphJson).mockResolvedValueOnce({
-      value: [{ id: "reply-1" }, { id: "reply-2" }],
-    } as never);
-
-    const result = await fetchThreadReplies("tok", "group-1", "channel-1", "msg-1");
-
-    expect(result).toHaveLength(2);
-    expect(fetchGraphJson).toHaveBeenCalledWith({
-      token: "tok",
-      path: "/teams/group-1/channels/channel-1/messages/msg-1/replies?$top=50&$select=id,from,body,createdDateTime",
-    });
-  });
-
-  it("clamps limit to 50 maximum", async () => {
-    vi.mocked(fetchGraphJson).mockResolvedValueOnce({ value: [] } as never);
-
-    await fetchThreadReplies("tok", "g", "c", "m", 200);
-
-    const path = vi.mocked(fetchGraphJson).mock.calls[0]?.[0]?.path ?? "";
-    expect(path).toContain("$top=50");
-  });
-
-  it("clamps limit to 1 minimum", async () => {
-    vi.mocked(fetchGraphJson).mockResolvedValueOnce({ value: [] } as never);
-
-    await fetchThreadReplies("tok", "g", "c", "m", 0);
-
-    const path = vi.mocked(fetchGraphJson).mock.calls[0]?.[0]?.path ?? "";
-    expect(path).toContain("$top=1");
-  });
-
-  it("returns empty array when value is missing", async () => {
-    vi.mocked(fetchGraphJson).mockResolvedValueOnce({} as never);
-
-    const result = await fetchThreadReplies("tok", "g", "c", "m");
-    expect(result).toEqual([]);
-  });
-});
-
-describe("formatThreadContext", () => {
-  it("formats messages as sender: content lines", () => {
-    const messages = [
-      {
-        id: "m1",
-        from: { user: { displayName: "Alice" } },
-        body: { content: "Hello!", contentType: "text" },
-      },
-      {
-        id: "m2",
-        from: { user: { displayName: "Bob" } },
-        body: { content: "World!", contentType: "text" },
-      },
-    ];
-    expect(formatThreadContext(messages)).toBe("Alice: Hello!\nBob: World!");
-  });
-
-  it("skips the current message by id", () => {
-    const messages = [
-      {
-        id: "m1",
-        from: { user: { displayName: "Alice" } },
-        body: { content: "Hello!", contentType: "text" },
-      },
-      {
-        id: "m2",
-        from: { user: { displayName: "Bob" } },
-        body: { content: "Current", contentType: "text" },
-      },
-    ];
-    expect(formatThreadContext(messages, "m2")).toBe("Alice: Hello!");
-  });
-
-  it("strips HTML from html contentType messages", () => {
-    const messages = [
-      {
-        id: "m1",
-        from: { user: { displayName: "Carol" } },
-        body: { content: "<p>Hello <b>world</b></p>", contentType: "html" },
-      },
-    ];
-    expect(formatThreadContext(messages)).toBe("Carol: Hello world");
-  });
-
-  it("uses application displayName when user is absent", () => {
-    const messages = [
-      {
-        id: "m1",
-        from: { application: { displayName: "BotApp" } },
-        body: { content: "automated msg", contentType: "text" },
-      },
-    ];
-    expect(formatThreadContext(messages)).toBe("BotApp: automated msg");
-  });
-
-  it("skips messages with empty content", () => {
-    const messages = [
-      {
-        id: "m1",
-        from: { user: { displayName: "Alice" } },
-        body: { content: "", contentType: "text" },
-      },
-      {
-        id: "m2",
-        from: { user: { displayName: "Bob" } },
-        body: { content: "actual content", contentType: "text" },
-      },
-    ];
-    expect(formatThreadContext(messages)).toBe("Bob: actual content");
-  });
-
-  it("falls back to 'unknown' sender when from is missing", () => {
-    const messages = [
-      {
-        id: "m1",
-        body: { content: "orphan msg", contentType: "text" },
-      },
-    ];
-    expect(formatThreadContext(messages)).toBe("unknown: orphan msg");
-  });
-
-  it("returns empty string for empty messages array", () => {
-    expect(formatThreadContext([])).toBe("");
-  });
-});