@openclaw/msteams 2026.5.2 → 2026.5.3-beta.1

package/src/session-route.ts

@@ -1,40 +0,0 @@
-import {
-  buildChannelOutboundSessionRoute,
-  stripChannelTargetPrefix,
-  stripTargetKindPrefix,
-  type ChannelOutboundSessionRouteParams,
-} from "openclaw/plugin-sdk/channel-core";
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
-
-export function resolveMSTeamsOutboundSessionRoute(params: ChannelOutboundSessionRouteParams) {
-  let trimmed = stripChannelTargetPrefix(params.target, "msteams", "teams");
-  if (!trimmed) {
-    return null;
-  }
-
-  const lower = normalizeLowercaseStringOrEmpty(trimmed);
-  const isUser = lower.startsWith("user:");
-  const rawId = stripTargetKindPrefix(trimmed);
-  if (!rawId) {
-    return null;
-  }
-  const conversationId = rawId.split(";")[0] ?? rawId;
-  const isChannel = !isUser && /@thread\.tacv2/i.test(conversationId);
-  return buildChannelOutboundSessionRoute({
-    cfg: params.cfg,
-    agentId: params.agentId,
-    channel: "msteams",
-    accountId: params.accountId,
-    peer: {
-      kind: isUser ? "direct" : isChannel ? "channel" : "group",
-      id: conversationId,
-    },
-    chatType: isUser ? "direct" : isChannel ? "channel" : "group",
-    from: isUser
-      ? `msteams:${conversationId}`
-      : isChannel
-        ? `msteams:channel:${conversationId}`
-        : `msteams:group:${conversationId}`,
-    to: isUser ? `user:${conversationId}` : `conversation:${conversationId}`,
-  });
-}

package/src/setup-core.ts

@@ -1,160 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import {
-  createStandardChannelSetupStatus,
-  DEFAULT_ACCOUNT_ID,
-  type ChannelSetupAdapter,
-  type ChannelSetupWizard,
-  type WizardPrompter,
-} from "openclaw/plugin-sdk/setup";
-import { formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
-import { normalizeSecretInputString } from "./secret-input.js";
-import { hasConfiguredMSTeamsCredentials, resolveMSTeamsCredentials } from "./token.js";
-
-export const msteamsSetupAdapter: ChannelSetupAdapter = {
-  resolveAccountId: () => DEFAULT_ACCOUNT_ID,
-  applyAccountConfig: ({ cfg }) => ({
-    ...cfg,
-    channels: {
-      ...cfg.channels,
-      msteams: {
-        ...cfg.channels?.msteams,
-        enabled: true,
-      },
-    },
-  }),
-};
-
-const channel = "msteams" as const;
-
-async function promptMSTeamsCredentials(prompter: WizardPrompter): Promise<{
-  appId: string;
-  appPassword: string;
-  tenantId: string;
-}> {
-  const appId = (
-    await prompter.text({
-      message: "Enter MS Teams App ID",
-      validate: (value) => (value?.trim() ? undefined : "Required"),
-    })
-  ).trim();
-  const appPassword = (
-    await prompter.text({
-      message: "Enter MS Teams App Password",
-      validate: (value) => (value?.trim() ? undefined : "Required"),
-    })
-  ).trim();
-  const tenantId = (
-    await prompter.text({
-      message: "Enter MS Teams Tenant ID",
-      validate: (value) => (value?.trim() ? undefined : "Required"),
-    })
-  ).trim();
-  return { appId, appPassword, tenantId };
-}
-
-async function noteMSTeamsCredentialHelp(prompter: WizardPrompter): Promise<void> {
-  await prompter.note(
-    [
-      "1) Azure Bot registration -> get App ID + Tenant ID",
-      "2) Add a client secret (App Password)",
-      "3) Set webhook URL + messaging endpoint",
-      "Tip: you can also set MSTEAMS_APP_ID / MSTEAMS_APP_PASSWORD / MSTEAMS_TENANT_ID.",
-      `Docs: ${formatDocsLink("/channels/msteams", "msteams")}`,
-    ].join("\n"),
-    "MS Teams credentials",
-  );
-}
-
-export function createMSTeamsSetupWizardBase(): Pick<
-  ChannelSetupWizard,
-  | "channel"
-  | "resolveAccountIdForConfigure"
-  | "resolveShouldPromptAccountIds"
-  | "status"
-  | "credentials"
-  | "finalize"
-> {
-  return {
-    channel,
-    resolveAccountIdForConfigure: () => DEFAULT_ACCOUNT_ID,
-    resolveShouldPromptAccountIds: () => false,
-    status: createStandardChannelSetupStatus({
-      channelLabel: "MS Teams",
-      configuredLabel: "configured",
-      unconfiguredLabel: "needs app credentials",
-      configuredHint: "configured",
-      unconfiguredHint: "needs app creds",
-      configuredScore: 2,
-      unconfiguredScore: 0,
-      includeStatusLine: true,
-      resolveConfigured: ({ cfg }) =>
-        Boolean(resolveMSTeamsCredentials(cfg.channels?.msteams)) ||
-        hasConfiguredMSTeamsCredentials(cfg.channels?.msteams),
-    }),
-    credentials: [],
-    finalize: async ({ cfg, prompter }) => {
-      const resolved = resolveMSTeamsCredentials(cfg.channels?.msteams);
-      const hasConfigCreds = hasConfiguredMSTeamsCredentials(cfg.channels?.msteams);
-      const canUseEnv = Boolean(
-        !hasConfigCreds &&
-        normalizeSecretInputString(process.env.MSTEAMS_APP_ID) &&
-        normalizeSecretInputString(process.env.MSTEAMS_APP_PASSWORD) &&
-        normalizeSecretInputString(process.env.MSTEAMS_TENANT_ID),
-      );
-
-      let next: OpenClawConfig = cfg;
-      let appId: string | null = null;
-      let appPassword: string | null = null;
-      let tenantId: string | null = null;
-
-      if (!resolved && !hasConfigCreds) {
-        await noteMSTeamsCredentialHelp(prompter);
-      }
-
-      if (canUseEnv) {
-        const keepEnv = await prompter.confirm({
-          message:
-            "MSTEAMS_APP_ID + MSTEAMS_APP_PASSWORD + MSTEAMS_TENANT_ID detected. Use env vars?",
-          initialValue: true,
-        });
-        if (keepEnv) {
-          next = msteamsSetupAdapter.applyAccountConfig({
-            cfg: next,
-            accountId: DEFAULT_ACCOUNT_ID,
-            input: {},
-          });
-        } else {
-          ({ appId, appPassword, tenantId } = await promptMSTeamsCredentials(prompter));
-        }
-      } else if (hasConfigCreds) {
-        const keep = await prompter.confirm({
-          message: "MS Teams credentials already configured. Keep them?",
-          initialValue: true,
-        });
-        if (!keep) {
-          ({ appId, appPassword, tenantId } = await promptMSTeamsCredentials(prompter));
-        }
-      } else {
-        ({ appId, appPassword, tenantId } = await promptMSTeamsCredentials(prompter));
-      }
-
-      if (appId && appPassword && tenantId) {
-        next = {
-          ...next,
-          channels: {
-            ...next.channels,
-            msteams: {
-              ...next.channels?.msteams,
-              enabled: true,
-              appId,
-              appPassword,
-              tenantId,
-            },
-          },
-        };
-      }
-
-      return { cfg: next, accountId: DEFAULT_ACCOUNT_ID };
-    },
-  };
-}

package/src/setup-surface.test.ts

@@ -1,202 +0,0 @@
-import { EventEmitter } from "node:events";
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/setup";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createMSTeamsSetupWizardBase, msteamsSetupAdapter } from "./setup-core.js";
-import { openDelegatedOAuthUrl } from "./setup-surface.js";
-
-const spawn = vi.hoisted(() => vi.fn());
-const resolveMSTeamsUserAllowlist = vi.hoisted(() => vi.fn());
-const resolveMSTeamsChannelAllowlist = vi.hoisted(() => vi.fn());
-const normalizeSecretInputString = vi.hoisted(() =>
-  vi.fn((value: unknown) => (typeof value === "string" ? value.trim() || undefined : undefined)),
-);
-const hasConfiguredMSTeamsCredentials = vi.hoisted(() => vi.fn());
-const resolveMSTeamsCredentials = vi.hoisted(() => vi.fn());
-
-vi.mock("./resolve-allowlist.js", () => ({
-  parseMSTeamsTeamEntry: vi.fn(),
-  resolveMSTeamsChannelAllowlist,
-  resolveMSTeamsUserAllowlist,
-}));
-
-vi.mock("./secret-input.js", () => ({
-  normalizeSecretInputString,
-}));
-
-vi.mock("./token.js", () => ({
-  hasConfiguredMSTeamsCredentials,
-  resolveMSTeamsCredentials,
-}));
-
-vi.mock("node:child_process", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:child_process")>();
-  return {
-    ...actual,
-    spawn,
-  };
-});
-
-describe("msteams setup surface", () => {
-  const msteamsSetupWizard = createMSTeamsSetupWizardBase();
-
-  beforeEach(() => {
-    spawn.mockReset();
-    resolveMSTeamsUserAllowlist.mockReset();
-    resolveMSTeamsChannelAllowlist.mockReset();
-    normalizeSecretInputString.mockClear();
-    hasConfiguredMSTeamsCredentials.mockReset();
-    resolveMSTeamsCredentials.mockReset();
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  it("always resolves to the default account", () => {
-    expect(msteamsSetupAdapter.resolveAccountId?.({ accountId: "work" } as never)).toBe(
-      DEFAULT_ACCOUNT_ID,
-    );
-  });
-
-  it("opens delegated OAuth URLs without invoking a shell", async () => {
-    const url = "https://login.microsoftonline.com/auth?state=$(touch pwned)";
-    const child = new EventEmitter();
-    spawn.mockReturnValue(child);
-
-    const result = openDelegatedOAuthUrl(url);
-    child.emit("exit", 0, null);
-
-    await expect(result).resolves.toBeUndefined();
-    expect(spawn).toHaveBeenCalledWith(process.platform === "darwin" ? "open" : "xdg-open", [url], {
-      stdio: "ignore",
-      shell: false,
-    });
-  });
-
-  it("enables the msteams channel without dropping existing config", () => {
-    expect(
-      msteamsSetupAdapter.applyAccountConfig?.({
-        cfg: {
-          channels: {
-            msteams: {
-              appId: "existing-app",
-            },
-          },
-        },
-        accountId: DEFAULT_ACCOUNT_ID,
-        input: {},
-      } as never),
-    ).toEqual({
-      channels: {
-        msteams: {
-          appId: "existing-app",
-          enabled: true,
-        },
-      },
-    });
-  });
-
-  it("reports configured status from resolved credentials", async () => {
-    resolveMSTeamsCredentials.mockReturnValue({
-      appId: "app",
-    });
-    hasConfiguredMSTeamsCredentials.mockReturnValue(false);
-
-    expect(
-      msteamsSetupWizard.status.resolveConfigured({
-        cfg: { channels: { msteams: {} } },
-      } as never),
-    ).toBe(true);
-  });
-
-  it("reports configured status from configured credentials and renders status lines", async () => {
-    resolveMSTeamsCredentials.mockReturnValue(null);
-    hasConfiguredMSTeamsCredentials.mockReturnValue(true);
-
-    expect(
-      msteamsSetupWizard.status.resolveConfigured({
-        cfg: { channels: { msteams: {} } },
-      } as never),
-    ).toBe(true);
-
-    hasConfiguredMSTeamsCredentials.mockReturnValue(false);
-    expect(msteamsSetupWizard.status.resolveStatusLines).toBeTypeOf("function");
-    await expect(
-      msteamsSetupWizard.status.resolveStatusLines?.({
-        cfg: { channels: { msteams: {} } },
-      } as never),
-    ).resolves.toEqual(["MS Teams: needs app credentials"]);
-  });
-
-  it("finalize keeps env credentials when available and accepted", async () => {
-    vi.stubEnv("MSTEAMS_APP_ID", "env-app");
-    vi.stubEnv("MSTEAMS_APP_PASSWORD", "env-secret");
-    vi.stubEnv("MSTEAMS_TENANT_ID", "env-tenant");
-    resolveMSTeamsCredentials.mockReturnValue(null);
-    hasConfiguredMSTeamsCredentials.mockReturnValue(false);
-
-    const result = await msteamsSetupWizard.finalize?.({
-      cfg: { channels: { msteams: { existing: true } } },
-      prompter: {
-        confirm: vi.fn(async () => true),
-        note: vi.fn(async () => {}),
-        text: vi.fn(),
-      },
-    } as never);
-
-    expect(result).toEqual({
-      accountId: "default",
-      cfg: {
-        channels: {
-          msteams: {
-            existing: true,
-            enabled: true,
-          },
-        },
-      },
-    });
-  });
-
-  it("finalize prompts for manual credentials when env/config creds are unavailable", async () => {
-    resolveMSTeamsCredentials.mockReturnValue(null);
-    hasConfiguredMSTeamsCredentials.mockReturnValue(false);
-    const note = vi.fn(async () => {});
-    const confirm = vi.fn(async () => false);
-    const text = vi.fn(async ({ message }: { message: string }) => {
-      if (message === "Enter MS Teams App ID") {
-        return "app-id";
-      }
-      if (message === "Enter MS Teams App Password") {
-        return "app-password";
-      }
-      if (message === "Enter MS Teams Tenant ID") {
-        return "tenant-id";
-      }
-      throw new Error(`Unexpected prompt: ${message}`);
-    });
-
-    const result = await msteamsSetupWizard.finalize?.({
-      cfg: { channels: { msteams: {} } },
-      prompter: {
-        confirm,
-        note,
-        text,
-      },
-    } as never);
-
-    expect(note).toHaveBeenCalled();
-    expect(result).toEqual({
-      accountId: "default",
-      cfg: {
-        channels: {
-          msteams: {
-            enabled: true,
-            appId: "app-id",
-            appPassword: "app-password",
-            tenantId: "tenant-id",
-          },
-        },
-      },
-    });
-  });
-});