@openclaw/msteams 2026.3.13 → 2026.5.1-beta.1

package/src/graph-teams.test.ts

@@ -0,0 +1,215 @@
+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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,246 @@
+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("");
+  });
+});