@poolzin/pool-bot 2026.2.17 → 2026.2.19

package/extensions/mattermost/src/mattermost/reactions.ts

@@ -0,0 +1,130 @@
+import type { PoolBotConfig } from "poolbot/plugin-sdk";
+import { resolveMattermostAccount } from "./accounts.js";
+import { createMattermostClient, fetchMattermostMe, type MattermostClient } from "./client.js";
+
+type Result = { ok: true } | { ok: false; error: string };
+
+const BOT_USER_CACHE_TTL_MS = 10 * 60_000;
+const botUserIdCache = new Map<string, { userId: string; expiresAt: number }>();
+
+async function resolveBotUserId(
+  client: MattermostClient,
+  cacheKey: string,
+): Promise<string | null> {
+  const cached = botUserIdCache.get(cacheKey);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.userId;
+  }
+  const me = await fetchMattermostMe(client);
+  const userId = me?.id?.trim();
+  if (!userId) {
+    return null;
+  }
+  botUserIdCache.set(cacheKey, { userId, expiresAt: Date.now() + BOT_USER_CACHE_TTL_MS });
+  return userId;
+}
+
+export async function addMattermostReaction(params: {
+  cfg: PoolBotConfig;
+  postId: string;
+  emojiName: string;
+  accountId?: string | null;
+  fetchImpl?: typeof fetch;
+}): Promise<Result> {
+  const resolved = resolveMattermostAccount({ cfg: params.cfg, accountId: params.accountId });
+  const baseUrl = resolved.baseUrl?.trim();
+  const botToken = resolved.botToken?.trim();
+  if (!baseUrl || !botToken) {
+    return { ok: false, error: "Mattermost botToken/baseUrl missing." };
+  }
+
+  const client = createMattermostClient({
+    baseUrl,
+    botToken,
+    fetchImpl: params.fetchImpl,
+  });
+
+  const cacheKey = `${baseUrl}:${botToken}`;
+  const userId = await resolveBotUserId(client, cacheKey);
+  if (!userId) {
+    return { ok: false, error: "Mattermost reactions failed: could not resolve bot user id." };
+  }
+
+  try {
+    await createReaction(client, {
+      userId,
+      postId: params.postId,
+      emojiName: params.emojiName,
+    });
+  } catch (err) {
+    return { ok: false, error: `Mattermost add reaction failed: ${String(err)}` };
+  }
+
+  return { ok: true };
+}
+
+export async function removeMattermostReaction(params: {
+  cfg: PoolBotConfig;
+  postId: string;
+  emojiName: string;
+  accountId?: string | null;
+  fetchImpl?: typeof fetch;
+}): Promise<Result> {
+  const resolved = resolveMattermostAccount({ cfg: params.cfg, accountId: params.accountId });
+  const baseUrl = resolved.baseUrl?.trim();
+  const botToken = resolved.botToken?.trim();
+  if (!baseUrl || !botToken) {
+    return { ok: false, error: "Mattermost botToken/baseUrl missing." };
+  }
+
+  const client = createMattermostClient({
+    baseUrl,
+    botToken,
+    fetchImpl: params.fetchImpl,
+  });
+
+  const cacheKey = `${baseUrl}:${botToken}`;
+  const userId = await resolveBotUserId(client, cacheKey);
+  if (!userId) {
+    return { ok: false, error: "Mattermost reactions failed: could not resolve bot user id." };
+  }
+
+  try {
+    await deleteReaction(client, {
+      userId,
+      postId: params.postId,
+      emojiName: params.emojiName,
+    });
+  } catch (err) {
+    return { ok: false, error: `Mattermost remove reaction failed: ${String(err)}` };
+  }
+
+  return { ok: true };
+}
+
+async function createReaction(
+  client: MattermostClient,
+  params: { userId: string; postId: string; emojiName: string },
+): Promise<void> {
+  await client.request<Record<string, unknown>>("/reactions", {
+    method: "POST",
+    body: JSON.stringify({
+      user_id: params.userId,
+      post_id: params.postId,
+      emoji_name: params.emojiName,
+    }),
+  });
+}
+
+async function deleteReaction(
+  client: MattermostClient,
+  params: { userId: string; postId: string; emojiName: string },
+): Promise<void> {
+  const emoji = encodeURIComponent(params.emojiName);
+  await client.request<unknown>(
+    `/users/${params.userId}/posts/${params.postId}/reactions/${emoji}`,
+    {
+      method: "DELETE",
+    },
+  );
+}

package/extensions/mattermost/src/mattermost/reconnect.ts

@@ -0,0 +1,103 @@
+export type ReconnectOutcome = "resolved" | "rejected";
+
+export type ShouldReconnectParams = {
+  attempt: number;
+  delayMs: number;
+  outcome: ReconnectOutcome;
+  error?: unknown;
+};
+
+export type RunWithReconnectOpts = {
+  abortSignal?: AbortSignal;
+  onError?: (err: unknown) => void;
+  onReconnect?: (delayMs: number) => void;
+  initialDelayMs?: number;
+  maxDelayMs?: number;
+  jitterRatio?: number;
+  random?: () => number;
+  shouldReconnect?: (params: ShouldReconnectParams) => boolean;
+};
+
+/**
+ * Reconnection loop with exponential backoff.
+ *
+ * Calls `connectFn` in a while loop. On normal resolve (connection closed),
+ * the backoff resets. On thrown error (connection failed), the current delay is
+ * used, then doubled for the next retry.
+ * The loop exits when `abortSignal` fires.
+ */
+export async function runWithReconnect(
+  connectFn: () => Promise<void>,
+  opts: RunWithReconnectOpts = {},
+): Promise<void> {
+  const { initialDelayMs = 2000, maxDelayMs = 60_000 } = opts;
+  const jitterRatio = Math.max(0, opts.jitterRatio ?? 0);
+  const random = opts.random ?? Math.random;
+  let retryDelay = initialDelayMs;
+  let attempt = 0;
+
+  while (!opts.abortSignal?.aborted) {
+    let shouldIncreaseDelay = false;
+    let outcome: ReconnectOutcome = "resolved";
+    let error: unknown;
+    try {
+      await connectFn();
+      retryDelay = initialDelayMs;
+    } catch (err) {
+      if (opts.abortSignal?.aborted) {
+        return;
+      }
+      outcome = "rejected";
+      error = err;
+      opts.onError?.(err);
+      shouldIncreaseDelay = true;
+    }
+    if (opts.abortSignal?.aborted) {
+      return;
+    }
+    const delayMs = withJitter(retryDelay, jitterRatio, random);
+    const shouldReconnect =
+      opts.shouldReconnect?.({
+        attempt,
+        delayMs,
+        outcome,
+        error,
+      }) ?? true;
+    if (!shouldReconnect) {
+      return;
+    }
+    opts.onReconnect?.(delayMs);
+    await sleepAbortable(delayMs, opts.abortSignal);
+    if (shouldIncreaseDelay) {
+      retryDelay = Math.min(retryDelay * 2, maxDelayMs);
+    }
+    attempt++;
+  }
+}
+
+function withJitter(baseMs: number, jitterRatio: number, random: () => number): number {
+  if (jitterRatio <= 0) {
+    return baseMs;
+  }
+  const normalized = Math.max(0, Math.min(1, random()));
+  const spread = baseMs * jitterRatio;
+  return Math.max(1, Math.round(baseMs - spread + normalized * spread * 2));
+}
+
+function sleepAbortable(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}

package/extensions/minimax-portal-auth/README.md

@@ -0,0 +1,33 @@
+# MiniMax OAuth (Pool Bot plugin)
+
+OAuth provider plugin for **MiniMax** (OAuth).
+
+## Enable
+
+Bundled plugins are disabled by default. Enable this one:
+
+```bash
+poolbot plugins enable minimax-portal-auth
+```
+
+Restart the Gateway after enabling.
+
+```bash
+poolbot gateway restart
+```
+
+## Authenticate
+
+```bash
+poolbot models auth login --provider minimax-portal --set-default
+```
+
+You will be prompted to select an endpoint:
+
+- **Global** - International users, optimized for overseas access (`api.minimax.io`)
+- **China** - Optimized for users in China (`api.minimaxi.com`)
+
+## Notes
+
+- MiniMax OAuth uses a user-code login flow.
+- Currently, OAuth login is supported only for the Coding plan

package/extensions/minimax-portal-auth/index.ts

@@ -0,0 +1,161 @@
+import {
+  emptyPluginConfigSchema,
+  type PoolBotPluginApi,
+  type ProviderAuthContext,
+  type ProviderAuthResult,
+} from "poolbot/plugin-sdk";
+import { loginMiniMaxPortalOAuth, type MiniMaxRegion } from "./oauth.js";
+
+const PROVIDER_ID = "minimax-portal";
+const PROVIDER_LABEL = "MiniMax";
+const DEFAULT_MODEL = "MiniMax-M2.5";
+const DEFAULT_BASE_URL_CN = "https://api.minimaxi.com/anthropic";
+const DEFAULT_BASE_URL_GLOBAL = "https://api.minimax.io/anthropic";
+const DEFAULT_CONTEXT_WINDOW = 200000;
+const DEFAULT_MAX_TOKENS = 8192;
+const OAUTH_PLACEHOLDER = "minimax-oauth";
+
+function getDefaultBaseUrl(region: MiniMaxRegion): string {
+  return region === "cn" ? DEFAULT_BASE_URL_CN : DEFAULT_BASE_URL_GLOBAL;
+}
+
+function modelRef(modelId: string): string {
+  return `${PROVIDER_ID}/${modelId}`;
+}
+
+function buildModelDefinition(params: {
+  id: string;
+  name: string;
+  input: Array<"text" | "image">;
+  reasoning?: boolean;
+}) {
+  return {
+    id: params.id,
+    name: params.name,
+    reasoning: params.reasoning ?? false,
+    input: params.input,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: DEFAULT_CONTEXT_WINDOW,
+    maxTokens: DEFAULT_MAX_TOKENS,
+  };
+}
+
+function createOAuthHandler(region: MiniMaxRegion) {
+  const defaultBaseUrl = getDefaultBaseUrl(region);
+  const regionLabel = region === "cn" ? "CN" : "Global";
+
+  return async (ctx: ProviderAuthContext): Promise<ProviderAuthResult> => {
+    const progress = ctx.prompter.progress(`Starting MiniMax OAuth (${regionLabel})…`);
+    try {
+      const result = await loginMiniMaxPortalOAuth({
+        openUrl: ctx.openUrl,
+        note: ctx.prompter.note,
+        progress,
+        region,
+      });
+
+      progress.stop("MiniMax OAuth complete");
+
+      if (result.notification_message) {
+        await ctx.prompter.note(result.notification_message, "MiniMax OAuth");
+      }
+
+      const profileId = `${PROVIDER_ID}:default`;
+      const baseUrl = result.resourceUrl || defaultBaseUrl;
+
+      return {
+        profiles: [
+          {
+            profileId,
+            credential: {
+              type: "oauth" as const,
+              provider: PROVIDER_ID,
+              access: result.access,
+              refresh: result.refresh,
+              expires: result.expires,
+            },
+          },
+        ],
+        configPatch: {
+          models: {
+            providers: {
+              [PROVIDER_ID]: {
+                baseUrl,
+                apiKey: OAUTH_PLACEHOLDER,
+                api: "anthropic-messages",
+                models: [
+                  buildModelDefinition({
+                    id: "MiniMax-M2.1",
+                    name: "MiniMax M2.1",
+                    input: ["text"],
+                  }),
+                  buildModelDefinition({
+                    id: "MiniMax-M2.5",
+                    name: "MiniMax M2.5",
+                    input: ["text"],
+                    reasoning: true,
+                  }),
+                ],
+              },
+            },
+          },
+          agents: {
+            defaults: {
+              models: {
+                [modelRef("MiniMax-M2.1")]: { alias: "minimax-m2.1" },
+                [modelRef("MiniMax-M2.5")]: { alias: "minimax-m2.5" },
+              },
+            },
+          },
+        },
+        defaultModel: modelRef(DEFAULT_MODEL),
+        notes: [
+          "MiniMax OAuth tokens auto-refresh. Re-run login if refresh fails or access is revoked.",
+          `Base URL defaults to ${defaultBaseUrl}. Override models.providers.${PROVIDER_ID}.baseUrl if needed.`,
+          ...(result.notification_message ? [result.notification_message] : []),
+        ],
+      };
+    } catch (err) {
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      progress.stop(`MiniMax OAuth failed: ${errorMsg}`);
+      await ctx.prompter.note(
+        "If OAuth fails, verify your MiniMax account has portal access and try again.",
+        "MiniMax OAuth",
+      );
+      throw err;
+    }
+  };
+}
+
+const minimaxPortalPlugin = {
+  id: "minimax-portal-auth",
+  name: "MiniMax OAuth",
+  description: "OAuth flow for MiniMax models",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: PoolBotPluginApi) {
+    api.registerProvider({
+      id: PROVIDER_ID,
+      label: PROVIDER_LABEL,
+      docsPath: "/providers/minimax",
+      aliases: ["minimax"],
+      auth: [
+        {
+          id: "oauth",
+          label: "MiniMax OAuth (Global)",
+          hint: "Global endpoint - api.minimax.io",
+          kind: "device_code",
+          run: createOAuthHandler("global"),
+        },
+        {
+          id: "oauth-cn",
+          label: "MiniMax OAuth (CN)",
+          hint: "CN endpoint - api.minimaxi.com",
+          kind: "device_code",
+          run: createOAuthHandler("cn"),
+        },
+      ],
+    });
+  },
+};
+
+export default minimaxPortalPlugin;

package/extensions/minimax-portal-auth/oauth.ts

@@ -0,0 +1,247 @@
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+
+export type MiniMaxRegion = "cn" | "global";
+
+const MINIMAX_OAUTH_CONFIG = {
+  cn: {
+    baseUrl: "https://api.minimaxi.com",
+    clientId: "78257093-7e40-4613-99e0-527b14b39113",
+  },
+  global: {
+    baseUrl: "https://api.minimax.io",
+    clientId: "78257093-7e40-4613-99e0-527b14b39113",
+  },
+} as const;
+
+const MINIMAX_OAUTH_SCOPE = "group_id profile model.completion";
+const MINIMAX_OAUTH_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:user_code";
+
+function getOAuthEndpoints(region: MiniMaxRegion) {
+  const config = MINIMAX_OAUTH_CONFIG[region];
+  return {
+    codeEndpoint: `${config.baseUrl}/oauth/code`,
+    tokenEndpoint: `${config.baseUrl}/oauth/token`,
+    clientId: config.clientId,
+    baseUrl: config.baseUrl,
+  };
+}
+
+export type MiniMaxOAuthAuthorization = {
+  user_code: string;
+  verification_uri: string;
+  expired_in: number;
+  interval?: number;
+  state: string;
+};
+
+export type MiniMaxOAuthToken = {
+  access: string;
+  refresh: string;
+  expires: number;
+  resourceUrl?: string;
+  notification_message?: string;
+};
+
+type TokenPending = { status: "pending"; message?: string };
+
+type TokenResult =
+  | { status: "success"; token: MiniMaxOAuthToken }
+  | TokenPending
+  | { status: "error"; message: string };
+
+function toFormUrlEncoded(data: Record<string, string>): string {
+  return Object.entries(data)
+    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+    .join("&");
+}
+
+function generatePkce(): { verifier: string; challenge: string; state: string } {
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  const state = randomBytes(16).toString("base64url");
+  return { verifier, challenge, state };
+}
+
+async function requestOAuthCode(params: {
+  challenge: string;
+  state: string;
+  region: MiniMaxRegion;
+}): Promise<MiniMaxOAuthAuthorization> {
+  const endpoints = getOAuthEndpoints(params.region);
+  const response = await fetch(endpoints.codeEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json",
+      "x-request-id": randomUUID(),
+    },
+    body: toFormUrlEncoded({
+      response_type: "code",
+      client_id: endpoints.clientId,
+      scope: MINIMAX_OAUTH_SCOPE,
+      code_challenge: params.challenge,
+      code_challenge_method: "S256",
+      state: params.state,
+    }),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`MiniMax OAuth authorization failed: ${text || response.statusText}`);
+  }
+
+  const payload = (await response.json()) as MiniMaxOAuthAuthorization & { error?: string };
+  if (!payload.user_code || !payload.verification_uri) {
+    throw new Error(
+      payload.error ??
+        "MiniMax OAuth authorization returned an incomplete payload (missing user_code or verification_uri).",
+    );
+  }
+  if (payload.state !== params.state) {
+    throw new Error("MiniMax OAuth state mismatch: possible CSRF attack or session corruption.");
+  }
+  return payload;
+}
+
+async function pollOAuthToken(params: {
+  userCode: string;
+  verifier: string;
+  region: MiniMaxRegion;
+}): Promise<TokenResult> {
+  const endpoints = getOAuthEndpoints(params.region);
+  const response = await fetch(endpoints.tokenEndpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      Accept: "application/json",
+    },
+    body: toFormUrlEncoded({
+      grant_type: MINIMAX_OAUTH_GRANT_TYPE,
+      client_id: endpoints.clientId,
+      user_code: params.userCode,
+      code_verifier: params.verifier,
+    }),
+  });
+
+  const text = await response.text();
+  let payload:
+    | {
+        status?: string;
+        base_resp?: { status_code?: number; status_msg?: string };
+      }
+    | undefined;
+  if (text) {
+    try {
+      payload = JSON.parse(text) as typeof payload;
+    } catch {
+      payload = undefined;
+    }
+  }
+
+  if (!response.ok) {
+    return {
+      status: "error",
+      message:
+        (payload?.base_resp?.status_msg ?? text) || "MiniMax OAuth failed to parse response.",
+    };
+  }
+
+  if (!payload) {
+    return { status: "error", message: "MiniMax OAuth failed to parse response." };
+  }
+
+  const tokenPayload = payload as {
+    status: string;
+    access_token?: string | null;
+    refresh_token?: string | null;
+    expired_in?: number | null;
+    token_type?: string;
+    resource_url?: string;
+    notification_message?: string;
+  };
+
+  if (tokenPayload.status === "error") {
+    return { status: "error", message: "An error occurred. Please try again later" };
+  }
+
+  if (tokenPayload.status != "success") {
+    return { status: "pending", message: "current user code is not authorized" };
+  }
+
+  if (!tokenPayload.access_token || !tokenPayload.refresh_token || !tokenPayload.expired_in) {
+    return { status: "error", message: "MiniMax OAuth returned incomplete token payload." };
+  }
+
+  return {
+    status: "success",
+    token: {
+      access: tokenPayload.access_token,
+      refresh: tokenPayload.refresh_token,
+      expires: tokenPayload.expired_in,
+      resourceUrl: tokenPayload.resource_url,
+      notification_message: tokenPayload.notification_message,
+    },
+  };
+}
+
+export async function loginMiniMaxPortalOAuth(params: {
+  openUrl: (url: string) => Promise<void>;
+  note: (message: string, title?: string) => Promise<void>;
+  progress: { update: (message: string) => void; stop: (message?: string) => void };
+  region?: MiniMaxRegion;
+}): Promise<MiniMaxOAuthToken> {
+  const region = params.region ?? "global";
+  const { verifier, challenge, state } = generatePkce();
+  const oauth = await requestOAuthCode({ challenge, state, region });
+  const verificationUrl = oauth.verification_uri;
+
+  const noteLines = [
+    `Open ${verificationUrl} to approve access.`,
+    `If prompted, enter the code ${oauth.user_code}.`,
+    `Interval: ${oauth.interval ?? "default (2000ms)"}, Expires at: ${oauth.expired_in} unix timestamp`,
+  ];
+  await params.note(noteLines.join("\n"), "MiniMax OAuth");
+
+  try {
+    await params.openUrl(verificationUrl);
+  } catch {
+    // Fall back to manual copy/paste if browser open fails.
+  }
+
+  let pollIntervalMs = oauth.interval ? oauth.interval : 2000;
+  const expireTimeMs = oauth.expired_in;
+
+  while (Date.now() < expireTimeMs) {
+    params.progress.update("Waiting for MiniMax OAuth approval…");
+    const result = await pollOAuthToken({
+      userCode: oauth.user_code,
+      verifier,
+      region,
+    });
+
+    // // Debug: print poll result
+    // await params.note(
+    //   `status: ${result.status}` +
+    //     (result.status === "success" ? `\ntoken: ${JSON.stringify(result.token, null, 2)}` : "") +
+    //     (result.status === "error" ? `\nmessage: ${result.message}` : "") +
+    //     (result.status === "pending" && result.message ? `\nmessage: ${result.message}` : ""),
+    //   "MiniMax OAuth Poll Result",
+    // );
+
+    if (result.status === "success") {
+      return result.token;
+    }
+
+    if (result.status === "error") {
+      throw new Error(`MiniMax OAuth failed: ${result.message}`);
+    }
+
+    if (result.status === "pending") {
+      pollIntervalMs = Math.min(pollIntervalMs * 1.5, 10000);
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+
+  throw new Error("MiniMax OAuth timed out waiting for authorization.");
+}

package/extensions/minimax-portal-auth/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@poolzin/minimax-portal-auth",
+  "version": "2026.2.18",
+  "private": true,
+  "description": "Pool Bot MiniMax Portal OAuth provider plugin",
+  "type": "module",
+  "devDependencies": {
+    "poolbot": "workspace:*"
+  },
+  "poolbot": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/extensions/minimax-portal-auth/poolbot.plugin.json

@@ -0,0 +1,9 @@
+{
+  "id": "minimax-portal-auth",
+  "providers": ["minimax-portal"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {}
+  }
+}

package/extensions/msteams/src/file-lock.ts

@@ -0,0 +1 @@
+export { withFileLock } from "poolbot/plugin-sdk";