@kodelyth/msteams 2026.5.42 → 2026.6.2

package/src/sent-message-cache.test.ts

@@ -1,106 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { setMSTeamsRuntime } from "./runtime.js";
-import {
-  clearMSTeamsSentMessageCache,
-  recordMSTeamsSentMessage,
-  wasMSTeamsMessageSent,
-  wasMSTeamsMessageSentWithPersistence,
-} from "./sent-message-cache.js";
-
-const TTL_MS = 24 * 60 * 60 * 1000;
-
-describe("msteams sent message cache", () => {
-  afterEach(() => {
-    clearMSTeamsSentMessageCache();
-    vi.restoreAllMocks();
-  });
-
-  it("records and resolves sent message ids", () => {
-    recordMSTeamsSentMessage("conv-1", "msg-1");
-    expect(wasMSTeamsMessageSent("conv-1", "msg-1")).toBe(true);
-    expect(wasMSTeamsMessageSent("conv-1", "msg-2")).toBe(false);
-  });
-
-  it("persists sent message ids when runtime state is available", async () => {
-    vi.spyOn(Date, "now").mockReturnValue(1_234_567);
-    const register = vi.fn().mockResolvedValue(undefined);
-    const lookup = vi.fn().mockResolvedValue({ sentAt: Date.now() });
-    const openKeyedStore = vi.fn(() => ({
-      register,
-      lookup,
-      consume: vi.fn(),
-      delete: vi.fn(),
-      entries: vi.fn(),
-      clear: vi.fn(),
-    }));
-    setMSTeamsRuntime({
-      state: { openKeyedStore },
-      logging: { getChildLogger: () => ({ warn: vi.fn() }) },
-    } as never);
-
-    recordMSTeamsSentMessage("conv-1", "msg-2");
-
-    await vi.waitFor(() => expect(register).toHaveBeenCalledTimes(1));
-    expect(register).toHaveBeenCalledWith("conv-1:msg-2", { sentAt: 1_234_567 });
-
-    clearMSTeamsSentMessageCache();
-    await expect(
-      wasMSTeamsMessageSentWithPersistence({ conversationId: "conv-1", messageId: "msg-2" }),
-    ).resolves.toBe(true);
-    expect(openKeyedStore).toHaveBeenCalledTimes(2);
-    expect(lookup).toHaveBeenCalledWith("conv-1:msg-2");
-
-    lookup.mockClear();
-    await expect(
-      wasMSTeamsMessageSentWithPersistence({ conversationId: "conv-1", messageId: "msg-2" }),
-    ).resolves.toBe(true);
-    expect(wasMSTeamsMessageSent("conv-1", "msg-2")).toBe(true);
-    expect(lookup).not.toHaveBeenCalled();
-  });
-
-  it("preserves the original TTL when recovering sent-message ids from persistent state", async () => {
-    const sentAt = 1_000_000;
-    const lookup = vi.fn().mockResolvedValue({ sentAt });
-    const openKeyedStore = vi.fn(() => ({
-      register: vi.fn(),
-      lookup,
-      consume: vi.fn(),
-      delete: vi.fn(),
-      entries: vi.fn(),
-      clear: vi.fn(),
-    }));
-    setMSTeamsRuntime({
-      state: { openKeyedStore },
-      logging: { getChildLogger: () => ({ warn: vi.fn() }) },
-    } as never);
-
-    vi.spyOn(Date, "now").mockReturnValue(sentAt + TTL_MS - 1);
-    await expect(
-      wasMSTeamsMessageSentWithPersistence({ conversationId: "conv-1", messageId: "msg-4" }),
-    ).resolves.toBe(true);
-    expect(wasMSTeamsMessageSent("conv-1", "msg-4")).toBe(true);
-
-    lookup.mockClear();
-    vi.mocked(Date.now).mockReturnValue(sentAt + TTL_MS + 1);
-
-    expect(wasMSTeamsMessageSent("conv-1", "msg-4")).toBe(false);
-    expect(lookup).not.toHaveBeenCalled();
-  });
-
-  it("falls back to in-memory sent-message markers when persistent state cannot open", () => {
-    const warn = vi.fn();
-    setMSTeamsRuntime({
-      state: {
-        openKeyedStore: vi.fn(() => {
-          throw new Error("sqlite unavailable");
-        }),
-      },
-      logging: { getChildLogger: () => ({ warn }) },
-    } as never);
-
-    recordMSTeamsSentMessage("conv-1", "msg-3");
-
-    expect(wasMSTeamsMessageSent("conv-1", "msg-3")).toBe(true);
-    expect(warn).toHaveBeenCalled();
-  });
-});

package/src/sent-message-cache.ts

@@ -1,174 +0,0 @@
-import { getOptionalMSTeamsRuntime } from "./runtime.js";
-
-const TTL_MS = 24 * 60 * 60 * 1000;
-const PERSISTENT_MAX_ENTRIES = 1000;
-const PERSISTENT_NAMESPACE = "msteams.sent-messages";
-const MSTEAMS_SENT_MESSAGES_KEY = Symbol.for("klaw.msteamsSentMessages");
-
-type MSTeamsSentMessageRecord = {
-  sentAt: number;
-};
-
-type MSTeamsSentMessageStore = {
-  register(key: string, value: MSTeamsSentMessageRecord, opts?: { ttlMs?: number }): Promise<void>;
-  lookup(key: string): Promise<MSTeamsSentMessageRecord | undefined>;
-};
-
-let sentMessageCache: Map<string, Map<string, number>> | undefined;
-let persistentStore: MSTeamsSentMessageStore | undefined;
-let persistentStoreDisabled = false;
-
-function getSentMessageCache(): Map<string, Map<string, number>> {
-  if (!sentMessageCache) {
-    const globalStore = globalThis as Record<PropertyKey, unknown>;
-    sentMessageCache =
-      (globalStore[MSTEAMS_SENT_MESSAGES_KEY] as Map<string, Map<string, number>> | undefined) ??
-      new Map<string, Map<string, number>>();
-    globalStore[MSTEAMS_SENT_MESSAGES_KEY] = sentMessageCache;
-  }
-  return sentMessageCache;
-}
-
-function makePersistentKey(conversationId: string, messageId: string): string {
-  return `${conversationId}:${messageId}`;
-}
-
-function reportPersistentSentMessageError(error: unknown): void {
-  try {
-    getOptionalMSTeamsRuntime()
-      ?.logging.getChildLogger({ plugin: "msteams", feature: "sent-message-state" })
-      .warn("Microsoft Teams persistent sent-message state failed", { error: String(error) });
-  } catch {
-    // Best effort only: persistent state must never break Teams routing.
-  }
-}
-
-function disablePersistentSentMessageStore(error: unknown): void {
-  persistentStoreDisabled = true;
-  persistentStore = undefined;
-  reportPersistentSentMessageError(error);
-}
-
-function getPersistentSentMessageStore(): MSTeamsSentMessageStore | undefined {
-  if (persistentStoreDisabled) {
-    return undefined;
-  }
-  if (persistentStore) {
-    return persistentStore;
-  }
-  const runtime = getOptionalMSTeamsRuntime();
-  if (!runtime) {
-    return undefined;
-  }
-  try {
-    persistentStore = runtime.state.openKeyedStore<MSTeamsSentMessageRecord>({
-      namespace: PERSISTENT_NAMESPACE,
-      maxEntries: PERSISTENT_MAX_ENTRIES,
-      defaultTtlMs: TTL_MS,
-    });
-    return persistentStore;
-  } catch (error) {
-    disablePersistentSentMessageStore(error);
-    return undefined;
-  }
-}
-
-function cleanupExpired(scopeKey: string, entry: Map<string, number>, now: number): void {
-  for (const [id, timestamp] of entry) {
-    if (now - timestamp > TTL_MS) {
-      entry.delete(id);
-    }
-  }
-  if (entry.size === 0) {
-    getSentMessageCache().delete(scopeKey);
-  }
-}
-
-function rememberSentMessageInMemory(
-  conversationId: string,
-  messageId: string,
-  sentAt: number,
-): void {
-  const store = getSentMessageCache();
-  let entry = store.get(conversationId);
-  if (!entry) {
-    entry = new Map<string, number>();
-    store.set(conversationId, entry);
-  }
-  entry.set(messageId, sentAt);
-  if (entry.size > 200) {
-    cleanupExpired(conversationId, entry, sentAt);
-  }
-}
-
-function rememberPersistentSentMessage(params: {
-  conversationId: string;
-  messageId: string;
-  sentAt: number;
-}): void {
-  const store = getPersistentSentMessageStore();
-  if (!store) {
-    return;
-  }
-  void store
-    .register(makePersistentKey(params.conversationId, params.messageId), { sentAt: params.sentAt })
-    .catch(disablePersistentSentMessageStore);
-}
-
-async function lookupPersistentSentMessage(params: {
-  conversationId: string;
-  messageId: string;
-}): Promise<number | undefined> {
-  const store = getPersistentSentMessageStore();
-  if (!store) {
-    return undefined;
-  }
-  try {
-    return (await store.lookup(makePersistentKey(params.conversationId, params.messageId)))?.sentAt;
-  } catch (error) {
-    disablePersistentSentMessageStore(error);
-    return undefined;
-  }
-}
-
-export function recordMSTeamsSentMessage(conversationId: string, messageId: string): void {
-  if (!conversationId || !messageId) {
-    return;
-  }
-  const now = Date.now();
-  rememberSentMessageInMemory(conversationId, messageId, now);
-  rememberPersistentSentMessage({ conversationId, messageId, sentAt: now });
-}
-
-export function wasMSTeamsMessageSent(conversationId: string, messageId: string): boolean {
-  const entry = getSentMessageCache().get(conversationId);
-  if (!entry) {
-    return false;
-  }
-  cleanupExpired(conversationId, entry, Date.now());
-  return entry.has(messageId);
-}
-
-export async function wasMSTeamsMessageSentWithPersistence(params: {
-  conversationId: string;
-  messageId: string;
-}): Promise<boolean> {
-  if (!params.conversationId || !params.messageId) {
-    return false;
-  }
-  if (wasMSTeamsMessageSent(params.conversationId, params.messageId)) {
-    return true;
-  }
-  const sentAt = await lookupPersistentSentMessage(params);
-  if (sentAt == null) {
-    return false;
-  }
-  rememberSentMessageInMemory(params.conversationId, params.messageId, sentAt);
-  return wasMSTeamsMessageSent(params.conversationId, params.messageId);
-}
-
-export function clearMSTeamsSentMessageCache(): void {
-  getSentMessageCache().clear();
-  persistentStore = undefined;
-  persistentStoreDisabled = false;
-}

package/src/session-route.ts

@@ -1,40 +0,0 @@
-import {
-  buildChannelOutboundSessionRoute,
-  stripChannelTargetPrefix,
-  stripTargetKindPrefix,
-  type ChannelOutboundSessionRouteParams,
-} from "klaw/plugin-sdk/channel-core";
-import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-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,162 +0,0 @@
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import {
-  createStandardChannelSetupStatus,
-  DEFAULT_ACCOUNT_ID,
-  createSetupTranslator,
-  type ChannelSetupAdapter,
-  type ChannelSetupWizard,
-  type WizardPrompter,
-} from "klaw/plugin-sdk/setup";
-import { formatDocsLink } from "klaw/plugin-sdk/setup-tools";
-import { normalizeSecretInputString } from "./secret-input.js";
-import { hasConfiguredMSTeamsCredentials, resolveMSTeamsCredentials } from "./token.js";
-
-const t = createSetupTranslator();
-
-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: t("wizard.msteams.appIdPrompt"),
-      validate: (value) => (value?.trim() ? undefined : t("common.required")),
-    })
-  ).trim();
-  const appPassword = (
-    await prompter.text({
-      message: t("wizard.msteams.appPasswordPrompt"),
-      validate: (value) => (value?.trim() ? undefined : t("common.required")),
-    })
-  ).trim();
-  const tenantId = (
-    await prompter.text({
-      message: t("wizard.msteams.tenantIdPrompt"),
-      validate: (value) => (value?.trim() ? undefined : t("common.required")),
-    })
-  ).trim();
-  return { appId, appPassword, tenantId };
-}
-
-async function noteMSTeamsCredentialHelp(prompter: WizardPrompter): Promise<void> {
-  await prompter.note(
-    [
-      t("wizard.msteams.helpAzureBot"),
-      t("wizard.msteams.helpClientSecret"),
-      t("wizard.msteams.helpWebhook"),
-      t("wizard.msteams.helpEnvTip"),
-      t("wizard.channels.docs", { link: formatDocsLink("/channels/msteams", "msteams") }),
-    ].join("\n"),
-    t("wizard.msteams.credentialsTitle"),
-  );
-}
-
-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: t("wizard.channels.statusConfigured"),
-      unconfiguredLabel: t("wizard.channels.statusNeedsAppCredentials"),
-      configuredHint: t("wizard.channels.statusConfigured"),
-      unconfiguredHint: t("wizard.channels.statusNeedsAppCreds"),
-      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: KlawConfig = 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: t("wizard.msteams.envPrompt"),
-          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: t("wizard.msteams.credentialsKeep"),
-          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,175 +0,0 @@
-import { DEFAULT_ACCOUNT_ID } from "klaw/plugin-sdk/setup";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { createMSTeamsSetupWizardBase, msteamsSetupAdapter } from "./setup-core.js";
-
-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,
-}));
-
-describe("msteams setup surface", () => {
-  const msteamsSetupWizard = createMSTeamsSetupWizardBase();
-
-  beforeEach(() => {
-    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("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", () => {
-    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",
-          },
-        },
-      },
-    });
-  });
-});