@ssfxx44533/onebot-qq 0.1.2

package/src/config.js

@@ -0,0 +1,380 @@
+import path from "node:path";
+
+export const CHANNEL_ID = "onebot-qq";
+export const DEFAULT_ACCOUNT_ID = "default";
+export const DEFAULT_WS_URL = "ws://localhost:3001/?access_token=napcat_ws";
+export const DEFAULT_CALL_TIMEOUT_MS = 10_000;
+export const DEFAULT_RECONNECT_BASE_MS = 2_000;
+export const DEFAULT_RECONNECT_MAX_MS = 30_000;
+export const DEFAULT_MAX_CHUNK_LENGTH = 1200;
+export const DEFAULT_DM_POLICY = "open";
+export const DEFAULT_GROUP_POLICY = "open";
+export const DEFAULT_GROUP_REQUIRE_MENTION = true;
+
+export const ONEBOT_QQ_CHANNEL_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    enabled: { type: "boolean" },
+    name: { type: "string" },
+    wsUrl: { type: "string" },
+    accessToken: { type: "string" },
+    selfId: { type: "string" },
+    defaultTo: { type: "string" },
+    dmPolicy: {
+      type: "string",
+      enum: ["open", "allowlist", "pairing", "disabled"],
+    },
+    groupPolicy: {
+      type: "string",
+      enum: ["open", "allowlist", "disabled"],
+    },
+    allowFrom: {
+      type: "array",
+      items: { type: "string" },
+    },
+    groupAllowFrom: {
+      type: "array",
+      items: { type: "string" },
+    },
+    requireMention: { type: "boolean" },
+    mediaMaxMb: { type: "number", minimum: 0 },
+    maxChunkLength: { type: "integer", minimum: 1 },
+    callTimeoutMs: { type: "integer", minimum: 1 },
+    reconnectBaseMs: { type: "integer", minimum: 1 },
+    reconnectMaxMs: { type: "integer", minimum: 1 },
+    groups: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          enabled: { type: "boolean" },
+          requireMention: { type: "boolean" },
+          systemPrompt: { type: "string" },
+          allowFrom: {
+            type: "array",
+            items: { type: "string" },
+          }
+        }
+      }
+    },
+    accounts: {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          enabled: { type: "boolean" },
+          name: { type: "string" },
+          wsUrl: { type: "string" },
+          accessToken: { type: "string" },
+          selfId: { type: "string" },
+          defaultTo: { type: "string" },
+          dmPolicy: {
+            type: "string",
+            enum: ["open", "allowlist", "pairing", "disabled"],
+          },
+          groupPolicy: {
+            type: "string",
+            enum: ["open", "allowlist", "disabled"],
+          },
+          allowFrom: {
+            type: "array",
+            items: { type: "string" },
+          },
+          groupAllowFrom: {
+            type: "array",
+            items: { type: "string" },
+          },
+          requireMention: { type: "boolean" },
+          mediaMaxMb: { type: "number", minimum: 0 },
+          maxChunkLength: { type: "integer", minimum: 1 },
+          callTimeoutMs: { type: "integer", minimum: 1 },
+          reconnectBaseMs: { type: "integer", minimum: 1 },
+          reconnectMaxMs: { type: "integer", minimum: 1 },
+          groups: {
+            type: "object",
+            additionalProperties: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                enabled: { type: "boolean" },
+                requireMention: { type: "boolean" },
+                systemPrompt: { type: "string" },
+                allowFrom: {
+                  type: "array",
+                  items: { type: "string" },
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+};
+
+function toPositiveInt(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function toIdList(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value
+    .map((entry) => String(entry ?? "").trim())
+    .filter(Boolean);
+}
+
+function resolveAccountSource(channelConfig, accountId) {
+  if (
+    channelConfig?.accounts &&
+    typeof channelConfig.accounts === "object" &&
+    !Array.isArray(channelConfig.accounts) &&
+    accountId &&
+    accountId !== DEFAULT_ACCOUNT_ID
+  ) {
+    const candidate = channelConfig.accounts[accountId];
+    if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
+      return candidate;
+    }
+  }
+  return {};
+}
+
+export function listOneBotAccountIds(cfg) {
+  const channelConfig = cfg?.channels?.[CHANNEL_ID];
+  if (!channelConfig || typeof channelConfig !== "object" || Array.isArray(channelConfig)) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  const accountIds = Object.keys(channelConfig.accounts ?? {}).filter(Boolean);
+  return accountIds.length > 0 ? accountIds : [DEFAULT_ACCOUNT_ID];
+}
+
+export function buildOneBotWsUrl({ wsUrl, accessToken }) {
+  const finalUrl = String(wsUrl ?? "").trim() || DEFAULT_WS_URL;
+  const token = String(accessToken ?? "").trim();
+  if (!token) {
+    return finalUrl;
+  }
+  const parsed = new URL(finalUrl);
+  if (!parsed.searchParams.has("access_token")) {
+    parsed.searchParams.set("access_token", token);
+  }
+  return parsed.toString();
+}
+
+export function resolveOneBotAccount(cfg, accountId = DEFAULT_ACCOUNT_ID) {
+  const channelConfig = cfg?.channels?.[CHANNEL_ID];
+  const base =
+    channelConfig && typeof channelConfig === "object" && !Array.isArray(channelConfig)
+      ? channelConfig
+      : {};
+  const scoped = resolveAccountSource(base, accountId);
+  const merged = { ...base, ...scoped };
+  const resolvedAccountId = String(accountId || DEFAULT_ACCOUNT_ID);
+  const name = String(merged.name ?? "OneBot QQ").trim() || "OneBot QQ";
+  const groups =
+    merged.groups && typeof merged.groups === "object" && !Array.isArray(merged.groups)
+      ? merged.groups
+      : {};
+
+  return {
+    accountId: resolvedAccountId,
+    name,
+    enabled: merged.enabled !== false,
+    configured: true,
+    wsUrl: buildOneBotWsUrl({
+      wsUrl: merged.wsUrl,
+      accessToken: merged.accessToken,
+    }),
+    selfId: String(merged.selfId ?? "").trim() || null,
+    defaultTo: String(merged.defaultTo ?? "").trim() || null,
+    dmPolicy: String(merged.dmPolicy ?? DEFAULT_DM_POLICY).trim() || DEFAULT_DM_POLICY,
+    groupPolicy: String(merged.groupPolicy ?? DEFAULT_GROUP_POLICY).trim() || DEFAULT_GROUP_POLICY,
+    requireMention:
+      typeof merged.requireMention === "boolean"
+        ? merged.requireMention
+        : DEFAULT_GROUP_REQUIRE_MENTION,
+    mediaMaxMb:
+      typeof merged.mediaMaxMb === "number" && merged.mediaMaxMb > 0
+        ? merged.mediaMaxMb
+        : undefined,
+    allowFrom: toIdList(merged.allowFrom),
+    groupAllowFrom: toIdList(merged.groupAllowFrom),
+    maxChunkLength: toPositiveInt(merged.maxChunkLength, DEFAULT_MAX_CHUNK_LENGTH),
+    callTimeoutMs: toPositiveInt(merged.callTimeoutMs, DEFAULT_CALL_TIMEOUT_MS),
+    reconnectBaseMs: toPositiveInt(merged.reconnectBaseMs, DEFAULT_RECONNECT_BASE_MS),
+    reconnectMaxMs: Math.max(
+      toPositiveInt(merged.reconnectMaxMs, DEFAULT_RECONNECT_MAX_MS),
+      toPositiveInt(merged.reconnectBaseMs, DEFAULT_RECONNECT_BASE_MS),
+    ),
+    groups,
+  };
+}
+
+export function resolveOneBotGroupConfig(account, groupId) {
+  const key = String(groupId ?? "").trim();
+  if (!key) {
+    return null;
+  }
+  const candidate = account?.groups?.[key];
+  if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+    return null;
+  }
+  return {
+    enabled: candidate.enabled !== false,
+    requireMention:
+      typeof candidate.requireMention === "boolean"
+        ? candidate.requireMention
+        : undefined,
+    systemPrompt:
+      typeof candidate.systemPrompt === "string" && candidate.systemPrompt.trim()
+        ? candidate.systemPrompt.trim()
+        : undefined,
+    allowFrom: toIdList(candidate.allowFrom),
+  };
+}
+
+export function normalizeAllowList(values) {
+  return toIdList(values)
+    .map((entry) => normalizeOneBotSenderEntry(entry))
+    .filter(Boolean);
+}
+
+export function matchAllowedSender(senderId, allowList) {
+  const normalizedSenderId = normalizeOneBotUserId(senderId);
+  if (!normalizedSenderId) {
+    return false;
+  }
+  const normalizedAllowList = normalizeAllowList(allowList);
+  return normalizedAllowList.includes("*") || normalizedAllowList.includes(normalizedSenderId);
+}
+
+export function resolveLocalFilePath(mediaUrl) {
+  const raw = String(mediaUrl ?? "").trim();
+  if (!raw) {
+    return raw;
+  }
+  if (raw.startsWith("file://")) {
+    return new URL(raw).pathname;
+  }
+  if (path.isAbsolute(raw)) {
+    return raw;
+  }
+  return path.resolve(raw);
+}
+
+export function isRemoteUrl(value) {
+  return /^https?:\/\//i.test(String(value ?? "").trim());
+}
+
+export function resolveMediaKind(mediaUrl) {
+  const raw = String(mediaUrl ?? "").trim();
+  if (!raw) {
+    return "file";
+  }
+  let pathname = raw;
+  if (isRemoteUrl(raw) || raw.startsWith("file://")) {
+    try {
+      pathname = new URL(raw).pathname;
+    } catch {
+      pathname = raw;
+    }
+  }
+  const ext = path.extname(pathname).toLowerCase();
+  if ([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"].includes(ext)) {
+    return "image";
+  }
+  if ([".mp3", ".wav", ".ogg", ".m4a", ".aac", ".flac", ".amr", ".silk"].includes(ext)) {
+    return "audio";
+  }
+  if ([".mp4", ".mov", ".webm", ".mkv"].includes(ext)) {
+    return "video";
+  }
+  return "file";
+}
+
+export function resolveUploadName(mediaUrl) {
+  const raw = String(mediaUrl ?? "").trim();
+  if (!raw) {
+    return "attachment";
+  }
+  if (isRemoteUrl(raw) || raw.startsWith("file://")) {
+    try {
+      return path.basename(new URL(raw).pathname) || "attachment";
+    } catch {
+      return path.basename(raw) || "attachment";
+    }
+  }
+  return path.basename(raw) || "attachment";
+}
+
+export function parseOutboundTarget(rawTarget, fallbackTarget = null) {
+  const raw = String(rawTarget ?? "").trim();
+  if (!raw) {
+    return fallbackTarget;
+  }
+
+  const groupId = normalizeOneBotGroupId(raw);
+  if (groupId) {
+    return {
+      chatType: "group",
+      targetId: groupId,
+      groupId,
+      userId: null,
+    };
+  }
+
+  const userId = normalizeOneBotUserId(raw);
+  if (userId) {
+    return {
+      chatType: "private",
+      targetId: userId,
+      groupId: null,
+      userId,
+    };
+  }
+
+  return null;
+}
+
+export function normalizeOneBotUserId(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw) {
+    return "";
+  }
+  const normalized = raw
+    .replace(/^onebot-qq:/i, "")
+    .replace(/^qq-private:/i, "")
+    .replace(/^(?:private|user|qq|qq-private|u):/i, "")
+    .trim();
+  return /^\d+$/.test(normalized) ? normalized : "";
+}
+
+export function normalizeOneBotGroupId(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw) {
+    return "";
+  }
+  const normalized = raw
+    .replace(/^onebot-qq:/i, "")
+    .replace(/^qq-group:/i, "")
+    .replace(/^(?:group|qq-group|g):/i, "")
+    .trim();
+  return /^\d+$/.test(normalized) ? normalized : "";
+}
+
+export function normalizeOneBotSenderEntry(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw) {
+    return "";
+  }
+  if (raw === "*") {
+    return "*";
+  }
+  return normalizeOneBotUserId(raw).toLowerCase();
+}