@poolzin/pool-bot 2026.2.24 → 2026.2.25

package/extensions/lobster/src/windows-spawn.ts

@@ -0,0 +1,193 @@
+import fs from "node:fs";
+import path from "node:path";
+
+type SpawnTarget = {
+  command: string;
+  argv: string[];
+  windowsHide?: boolean;
+};
+
+function isFilePath(value: string): boolean {
+  try {
+    const stat = fs.statSync(value);
+    return stat.isFile();
+  } catch {
+    return false;
+  }
+}
+
+function resolveWindowsExecutablePath(execPath: string, env: NodeJS.ProcessEnv): string {
+  if (execPath.includes("/") || execPath.includes("\\") || path.isAbsolute(execPath)) {
+    return execPath;
+  }
+
+  const pathValue = env.PATH ?? env.Path ?? process.env.PATH ?? process.env.Path ?? "";
+  const pathEntries = pathValue
+    .split(";")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+
+  const hasExtension = path.extname(execPath).length > 0;
+  const pathExtRaw =
+    env.PATHEXT ??
+    env.Pathext ??
+    process.env.PATHEXT ??
+    process.env.Pathext ??
+    ".EXE;.CMD;.BAT;.COM";
+  const pathExt = hasExtension
+    ? [""]
+    : pathExtRaw
+        .split(";")
+        .map((ext) => ext.trim())
+        .filter(Boolean)
+        .map((ext) => (ext.startsWith(".") ? ext : `.${ext}`));
+
+  for (const dir of pathEntries) {
+    for (const ext of pathExt) {
+      for (const candidateExt of [ext, ext.toLowerCase(), ext.toUpperCase()]) {
+        const candidate = path.join(dir, `${execPath}${candidateExt}`);
+        if (isFilePath(candidate)) {
+          return candidate;
+        }
+      }
+    }
+  }
+
+  return execPath;
+}
+
+function resolveBinEntry(binField: string | Record<string, string> | undefined): string | null {
+  if (typeof binField === "string") {
+    const trimmed = binField.trim();
+    return trimmed || null;
+  }
+  if (!binField || typeof binField !== "object") {
+    return null;
+  }
+
+  const preferred = binField.lobster;
+  if (typeof preferred === "string" && preferred.trim()) {
+    return preferred.trim();
+  }
+
+  for (const value of Object.values(binField)) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+
+function resolveLobsterScriptFromPackageJson(wrapperPath: string): string | null {
+  const wrapperDir = path.dirname(wrapperPath);
+  const packageDirs = [
+    // Local install: <repo>/node_modules/.bin/lobster.cmd -> ../lobster
+    path.resolve(wrapperDir, "..", "lobster"),
+    // Global npm install: <npm-prefix>/lobster.cmd -> ./node_modules/lobster
+    path.resolve(wrapperDir, "node_modules", "lobster"),
+  ];
+
+  for (const packageDir of packageDirs) {
+    const packageJsonPath = path.join(packageDir, "package.json");
+    if (!isFilePath(packageJsonPath)) {
+      continue;
+    }
+
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")) as {
+        bin?: string | Record<string, string>;
+      };
+      const scriptRel = resolveBinEntry(packageJson.bin);
+      if (!scriptRel) {
+        continue;
+      }
+      const scriptPath = path.resolve(packageDir, scriptRel);
+      if (isFilePath(scriptPath)) {
+        return scriptPath;
+      }
+    } catch {
+      // Ignore malformed package metadata; caller will throw a guided error.
+    }
+  }
+
+  return null;
+}
+
+function resolveLobsterScriptFromCmdShim(wrapperPath: string): string | null {
+  if (!isFilePath(wrapperPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(wrapperPath, "utf8");
+    const candidates: string[] = [];
+    const extractRelativeFromToken = (token: string): string | null => {
+      const match = token.match(/%~?dp0%\s*[\\/]*(.*)$/i);
+      if (!match) {
+        return null;
+      }
+      const relative = match[1];
+      if (!relative) {
+        return null;
+      }
+      return relative;
+    };
+
+    const matches = content.matchAll(/"([^"\r\n]*)"/g);
+    for (const match of matches) {
+      const token = match[1] ?? "";
+      const relative = extractRelativeFromToken(token);
+      if (!relative) {
+        continue;
+      }
+
+      const normalizedRelative = relative
+        .trim()
+        .replace(/[\\/]+/g, path.sep)
+        .replace(/^[\\/]+/, "");
+      const candidate = path.resolve(path.dirname(wrapperPath), normalizedRelative);
+      if (isFilePath(candidate)) {
+        candidates.push(candidate);
+      }
+    }
+
+    const nonNode = candidates.find((candidate) => {
+      const base = path.basename(candidate).toLowerCase();
+      return base !== "node.exe" && base !== "node";
+    });
+    if (nonNode) {
+      return nonNode;
+    }
+  } catch {
+    // Ignore unreadable shims; caller will throw a guided error.
+  }
+
+  return null;
+}
+
+export function resolveWindowsLobsterSpawn(
+  execPath: string,
+  argv: string[],
+  env: NodeJS.ProcessEnv,
+): SpawnTarget {
+  const resolvedExecPath = resolveWindowsExecutablePath(execPath, env);
+  const ext = path.extname(resolvedExecPath).toLowerCase();
+  if (ext !== ".cmd" && ext !== ".bat") {
+    return { command: resolvedExecPath, argv };
+  }
+
+  const scriptPath =
+    resolveLobsterScriptFromCmdShim(resolvedExecPath) ??
+    resolveLobsterScriptFromPackageJson(resolvedExecPath);
+  if (!scriptPath) {
+    throw new Error(
+      `${path.basename(resolvedExecPath)} wrapper resolved, but no Node entrypoint could be resolved without shell execution. Ensure Lobster is installed and runnable on PATH (prefer lobster.exe).`,
+    );
+  }
+
+  const entryExt = path.extname(scriptPath).toLowerCase();
+  if (entryExt === ".exe") {
+    return { command: scriptPath, argv, windowsHide: true };
+  }
+  return { command: process.execPath, argv: [scriptPath, ...argv], windowsHide: true };
+}

package/extensions/matrix/src/matrix/actions/limits.ts

@@ -0,0 +1,6 @@
+export function resolveMatrixActionLimit(raw: unknown, fallback: number): number {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    return fallback;
+  }
+  return Math.max(1, Math.floor(raw));
+}

package/extensions/mattermost/src/mattermost/reactions.test-helpers.ts

@@ -0,0 +1,83 @@
+import type { PoolBotConfig } from "poolbot/plugin-sdk";
+import { expect, vi } from "vitest";
+
+export function createMattermostTestConfig(): PoolBotConfig {
+  return {
+    channels: {
+      mattermost: {
+        enabled: true,
+        botToken: "test-token",
+        baseUrl: "https://chat.example.com",
+      },
+    },
+  };
+}
+
+export function createMattermostReactionFetchMock(params: {
+  postId: string;
+  emojiName: string;
+  mode: "add" | "remove" | "both";
+  userId?: string;
+  status?: number;
+  body?: unknown;
+}) {
+  const userId = params.userId ?? "BOT123";
+  const mode = params.mode;
+  const allowAdd = mode === "add" || mode === "both";
+  const allowRemove = mode === "remove" || mode === "both";
+  const addStatus = params.status ?? 201;
+  const removeStatus = params.status ?? 204;
+  const removePath = `/api/v4/users/${userId}/posts/${params.postId}/reactions/${encodeURIComponent(params.emojiName)}`;
+
+  return vi.fn(async (url: any, init?: any) => {
+    if (String(url).endsWith("/api/v4/users/me")) {
+      return new Response(JSON.stringify({ id: userId }), {
+        status: 200,
+        headers: { "content-type": "application/json" },
+      });
+    }
+
+    if (allowAdd && String(url).endsWith("/api/v4/reactions")) {
+      expect(init?.method).toBe("POST");
+      expect(JSON.parse(init?.body)).toEqual({
+        user_id: userId,
+        post_id: params.postId,
+        emoji_name: params.emojiName,
+      });
+
+      const responseBody = params.body === undefined ? { ok: true } : params.body;
+      return new Response(
+        responseBody === null ? null : JSON.stringify(responseBody),
+        responseBody === null
+          ? { status: addStatus, headers: { "content-type": "text/plain" } }
+          : { status: addStatus, headers: { "content-type": "application/json" } },
+      );
+    }
+
+    if (allowRemove && String(url).endsWith(removePath)) {
+      expect(init?.method).toBe("DELETE");
+      const responseBody = params.body === undefined ? null : params.body;
+      return new Response(
+        responseBody === null ? null : JSON.stringify(responseBody),
+        responseBody === null
+          ? { status: removeStatus, headers: { "content-type": "text/plain" } }
+          : { status: removeStatus, headers: { "content-type": "application/json" } },
+      );
+    }
+
+    throw new Error(`unexpected url: ${url}`);
+  });
+}
+
+export async function withMockedGlobalFetch<T>(
+  fetchImpl: typeof fetch,
+  run: () => Promise<T>,
+): Promise<T> {
+  const prevFetch = globalThis.fetch;
+  (globalThis as any).fetch = fetchImpl;
+  try {
+    return await run();
+  } finally {
+    (globalThis as any).fetch = prevFetch;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.2.24",
+  "version": "2026.2.25",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "keywords": [],
   "license": "MIT",