mslxdff 0.1.64 → 0.1.66

package/src/state/schemas/provider.js

@@ -0,0 +1,254 @@
+import { defaultStateFile, readState, writeStateImmediate } from "../store.js";
+
+export const WORKBUDDY_DEFAULT_BASE_URL = "https://copilot.tencent.com";
+
+export function normalizeBaseUrl(url) {
+  const s = String(url || "").trim();
+  if (!s) return "";
+  return s.replace(/\/+$/, "");
+}
+export function normalizeAuths(list) {
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const a of list) {
+    if (!a || typeof a !== "object") continue;
+    const uid = String(a.uid || a.userId || "").trim();
+    if (!uid) continue;
+    out.push({
+      uid,
+      domain: String(a.domain || "www.codebuddy.cn").trim() || "www.codebuddy.cn",
+      enterpriseId: String(a.enterpriseId || a.enterprise_id || "").trim(),
+      refreshToken: String(a.refreshToken || a.refresh_token || "").trim(),
+    });
+  }
+  return out;
+}
+export function normalizeAllowedModel(model, providerId) {
+  let s = String(model || "").trim();
+  if (!s) return "";
+  const idx = s.indexOf("/");
+  if (idx > 0) {
+    const head = s.slice(0, idx).toLowerCase();
+    if (head === String(providerId || "").toLowerCase()) s = s.slice(idx + 1);
+  }
+  return s;
+}
+export function normalizeEndpointPath(v) {
+  const s = String(v || "").trim();
+  if (!s) return "";
+  return s.startsWith("/") ? s : `/${s}`;
+}
+export function defaultModelsPath(id) {
+  if (String(id).toLowerCase() === "workbuddy") return "/console/enterprises/personal/models";
+  return "/models";
+}
+export function defaultChatPath(id) {
+  if (String(id).toLowerCase() === "workbuddy") return "/v2/chat/completions";
+  return "/chat/completions";
+}
+export function loadProviderModelsPath(id, { file = defaultStateFile() } = {}) {
+  const cfg = loadProviderConfigs({ file })[id];
+  if (cfg && typeof cfg.modelsPath === "string" && cfg.modelsPath.trim()) return normalizeEndpointPath(cfg.modelsPath);
+  return defaultModelsPath(id);
+}
+export function loadProviderChatPath(id, { file = defaultStateFile() } = {}) {
+  const cfg = loadProviderConfigs({ file })[id];
+  if (cfg && typeof cfg.chatPath === "string" && cfg.chatPath.trim()) return normalizeEndpointPath(cfg.chatPath);
+  return defaultChatPath(id);
+}
+
+export const providerKeyEnv = (id) => `MSLXDFF_${String(id || "").toUpperCase().replace(/[^A-Z0-9]/g, "_")}_KEY`;
+export const providerBaseUrlEnv = (id) => `MSLXDFF_${String(id || "").toUpperCase().replace(/[^A-Z0-9]/g, "_")}_BASE_URL`;
+export const providerShareEnv = (id) => `MSLXDFF_${String(id || "").toUpperCase().replace(/[^A-Z0-9]/g, "_")}_SHARE_KEYS`;
+
+export function loadProviderKeys(id, { file = defaultStateFile() } = {}) {
+  const env = (process.env[providerKeyEnv(id)] || "").trim();
+  if (env) return [env];
+  const configs = readState(file).providerConfigs;
+  const cfg = configs && typeof configs === "object" ? configs[id] : undefined;
+  if (cfg && typeof cfg === "object" && Array.isArray(cfg.keys)) {
+    const list = [...new Set(cfg.keys.filter((x) => typeof x === "string" && x.trim().length))];
+    if (list.length) return list;
+  }
+  const keys = readState(file).providerKeys;
+  const v = keys && typeof keys === "object" ? keys[id] : undefined;
+  if (typeof v === "string") return v.trim() ? [v.trim()] : [];
+  if (Array.isArray(v)) return [...new Set(v.filter((x) => typeof x === "string" && x.trim().length))];
+  return [];
+}
+
+export function loadProviderKey(id, opts = {}) {
+  return loadProviderKeys(id, opts)[0] || "";
+}
+
+export function saveProviderKeys(id, list, { file = defaultStateFile() } = {}) {
+  const keys = { ...(readState(file).providerKeys || {}) };
+  const clean = [...new Set((Array.isArray(list) ? list : []).map((k) => String(k || "").trim()).filter(Boolean))];
+  if (clean.length) keys[id] = clean;
+  else delete keys[id];
+  writeStateImmediate(file, { providerKeys: keys });
+  return clean;
+}
+
+export function saveProviderKey(id, key, opts = {}) {
+  const list = [...loadProviderKeys(id, opts)];
+  const clean = String(key || "").trim();
+  if (clean && !list.includes(clean)) list.push(clean);
+  return saveProviderKeys(id, clean ? list : [], opts);
+}
+
+export function addProviderKey(id, key, opts = {}) {
+  return saveProviderKey(id, key, opts);
+}
+
+export function removeProviderKey(id, key, opts = {}) {
+  return removeProviderKeys(id, [key], opts);
+}
+
+export function removeProviderKeys(id, targets = [], opts = {}) {
+  const set = new Set((Array.isArray(targets) ? targets : [targets]).map((k) => String(k || "").trim()).filter(Boolean));
+  const list = loadProviderKeys(id, opts).filter((k) => !set.has(k));
+  return saveProviderKeys(id, list, opts);
+}
+
+export function loadProviderShareKeys(id, { file = defaultStateFile() } = {}) {
+  const env = process.env[providerShareEnv(id)] || "";
+  if (env) return ["1", "true", "on", "yes"].includes(String(env).trim().toLowerCase());
+  const map = readState(file).providerShareKeys;
+  return !!(map && typeof map === "object" && map[id]);
+}
+
+export function saveProviderShareKeys(id, on, { file = defaultStateFile() } = {}) {
+  const map = { ...(readState(file).providerShareKeys || {}) };
+  if (on) map[id] = true;
+  else delete map[id];
+  writeStateImmediate(file, { providerShareKeys: map });
+  return !!on;
+}
+
+export function loadProviderConfigs({ file = defaultStateFile() } = {}) {
+  const v = readState(file).providerConfigs;
+  if (v && typeof v === "object" && !Array.isArray(v)) return v;
+  return {};
+}
+
+export function loadProviderConfig(id, { file = defaultStateFile() } = {}) {
+  const envUrl = (process.env[providerBaseUrlEnv(id)] || "").trim();
+  const envKeys = loadProviderKeys(id, { file });
+  if (envUrl || (process.env[providerKeyEnv(id)] || "").trim()) {
+    const baseUrl = envUrl || loadProviderConfigs({ file })[id]?.baseUrl || (String(id).toLowerCase() === "workbuddy" ? WORKBUDDY_DEFAULT_BASE_URL : "");
+    const cfg = loadProviderConfigs({ file })[id];
+    const allowedModels = cfg && Array.isArray(cfg.allowedModels) ? [...new Set(cfg.allowedModels.map((m) => normalizeAllowedModel(m, id)).filter(Boolean))] : [];
+    const auths = cfg && Array.isArray(cfg.auths) ? normalizeAuths(cfg.auths) : [];
+    const modelsPath = cfg && typeof cfg.modelsPath === "string" && cfg.modelsPath.trim() ? normalizeEndpointPath(cfg.modelsPath) : defaultModelsPath(id);
+    const chatPath = cfg && typeof cfg.chatPath === "string" && cfg.chatPath.trim() ? normalizeEndpointPath(cfg.chatPath) : defaultChatPath(id);
+    if (baseUrl || envKeys.length || allowedModels.length || auths.length) return { baseUrl: normalizeBaseUrl(baseUrl), keys: envKeys, auths, allowedModels, modelsPath, chatPath };
+    return null;
+  }
+  const configs = loadProviderConfigs({ file });
+  const cfg = configs[id];
+  if (cfg && typeof cfg === "object") {
+    return {
+      baseUrl: normalizeBaseUrl(cfg.baseUrl || (String(id).toLowerCase() === "workbuddy" ? WORKBUDDY_DEFAULT_BASE_URL : "")),
+      keys: Array.isArray(cfg.keys) ? [...new Set(cfg.keys.filter((x) => typeof x === "string" && x.trim().length))] : [],
+      auths: normalizeAuths(cfg.auths),
+      allowedModels: Array.isArray(cfg.allowedModels) ? [...new Set(cfg.allowedModels.map((m) => normalizeAllowedModel(m, id)).filter(Boolean))] : [],
+      modelsPath: typeof cfg.modelsPath === "string" && cfg.modelsPath.trim() ? normalizeEndpointPath(cfg.modelsPath) : defaultModelsPath(id),
+      chatPath: typeof cfg.chatPath === "string" && cfg.chatPath.trim() ? normalizeEndpointPath(cfg.chatPath) : defaultChatPath(id),
+    };
+  }
+  const keys = loadProviderKeys(id, { file });
+  if (keys.length) return { baseUrl: String(id).toLowerCase() === "workbuddy" ? WORKBUDDY_DEFAULT_BASE_URL : "", keys, auths: [], allowedModels: [], modelsPath: defaultModelsPath(id), chatPath: defaultChatPath(id) };
+  return null;
+}
+
+export function loadProviderBaseUrl(id, opts = {}) {
+  const env = (process.env[providerBaseUrlEnv(id)] || "").trim();
+  if (env) return normalizeBaseUrl(env);
+  const cfg = loadProviderConfigs(opts)[id];
+  if (cfg && typeof cfg.baseUrl === "string" && normalizeBaseUrl(cfg.baseUrl)) return normalizeBaseUrl(cfg.baseUrl);
+  if (String(id || "").toLowerCase() === "workbuddy") return WORKBUDDY_DEFAULT_BASE_URL;
+  return "";
+}
+
+export function loadProviderAuths(id, { file = defaultStateFile() } = {}) {
+  const cfg = loadProviderConfigs({ file })[id];
+  if (cfg && Array.isArray(cfg.auths)) return normalizeAuths(cfg.auths);
+  return [];
+}
+export function saveProviderAuths(id, list, { file = defaultStateFile() } = {}) {
+  const clean = normalizeAuths(list);
+  const configs = { ...loadProviderConfigs({ file }) };
+  const cur = configs[id] && typeof configs[id] === "object" ? configs[id] : {};
+  const baseUrl = normalizeBaseUrl(cur.baseUrl || loadProviderBaseUrl(id, { file }) || "");
+  const keys = Array.isArray(cur.keys) ? [...new Set(cur.keys.filter((x) => typeof x === "string" && x.trim().length))] : loadProviderKeys(id, { file });
+  const allowedModels = Array.isArray(cur.allowedModels) ? [...new Set(cur.allowedModels.map((m) => normalizeAllowedModel(m, id)).filter(Boolean))] : [];
+  const modelsPath = typeof cur.modelsPath === "string" ? normalizeEndpointPath(cur.modelsPath) : "";
+  const chatPath = typeof cur.chatPath === "string" ? normalizeEndpointPath(cur.chatPath) : "";
+  if (!baseUrl && !keys.length && !clean.length && !allowedModels.length && !modelsPath && !chatPath) {
+    delete configs[id];
+  } else {
+    configs[id] = { baseUrl, keys };
+    if (clean.length) configs[id].auths = clean;
+    if (allowedModels.length) configs[id].allowedModels = allowedModels;
+    if (modelsPath) configs[id].modelsPath = modelsPath;
+    if (chatPath) configs[id].chatPath = chatPath;
+  }
+  writeStateImmediate(file, { providerConfigs: configs });
+  return clean;
+}
+
+export function saveProviderBaseUrl(id, baseUrl, { file = defaultStateFile() } = {}) {
+  const clean = normalizeBaseUrl(baseUrl);
+  const configs = { ...loadProviderConfigs({ file }) };
+  const cur = configs[id] && typeof configs[id] === "object" ? configs[id] : {};
+  const keys = Array.isArray(cur.keys) ? cur.keys : loadProviderKeys(id, { file });
+  const auths = normalizeAuths(cur.auths);
+  const allowedModels = Array.isArray(cur.allowedModels) ? [...new Set(cur.allowedModels.map((m) => normalizeAllowedModel(m, id)).filter(Boolean))] : [];
+  const modelsPath = typeof cur.modelsPath === "string" ? normalizeEndpointPath(cur.modelsPath) : "";
+  const chatPath = typeof cur.chatPath === "string" ? normalizeEndpointPath(cur.chatPath) : "";
+  if (!clean && !keys.length && !auths.length && !allowedModels.length && !modelsPath && !chatPath) {
+    delete configs[id];
+  } else {
+    configs[id] = { baseUrl: clean, keys };
+    if (auths.length) configs[id].auths = auths;
+    if (allowedModels.length) configs[id].allowedModels = allowedModels;
+    if (modelsPath) configs[id].modelsPath = modelsPath;
+    if (chatPath) configs[id].chatPath = chatPath;
+  }
+  writeStateImmediate(file, { providerConfigs: configs });
+  return clean;
+}
+
+export function saveProviderConfig(id, { baseUrl, keys, auths, allowedModels, modelsPath, chatPath }, { file = defaultStateFile() } = {}) {
+  const cleanUrl = normalizeBaseUrl(baseUrl);
+  const cleanKeys = [...new Set((Array.isArray(keys) ? keys : []).map((k) => String(k || "").trim()).filter(Boolean))];
+  const cleanAuths = auths === undefined ? undefined : normalizeAuths(auths);
+  const cleanAllowed = [...new Set((Array.isArray(allowedModels) ? allowedModels : []).map((m) => normalizeAllowedModel(m, id)).filter(Boolean))];
+  const cleanModelsPath = modelsPath === undefined ? undefined : (String(modelsPath).trim() ? normalizeEndpointPath(modelsPath) : "");
+  const cleanChatPath = chatPath === undefined ? undefined : (String(chatPath).trim() ? normalizeEndpointPath(chatPath) : "");
+  const configs = { ...loadProviderConfigs({ file }) };
+  const cur = configs[id] && typeof configs[id] === "object" ? configs[id] : {};
+  const finalAllowed = allowedModels === undefined ? (Array.isArray(cur.allowedModels) ? [...new Set(cur.allowedModels.map((m) => normalizeAllowedModel(m, id)).filter(Boolean))] : []) : cleanAllowed;
+  const finalAuths = cleanAuths === undefined ? normalizeAuths(cur.auths) : cleanAuths;
+  const finalModelsPath = cleanModelsPath === undefined ? (typeof cur.modelsPath === "string" ? normalizeEndpointPath(cur.modelsPath) : "") : cleanModelsPath;
+  const finalChatPath = cleanChatPath === undefined ? (typeof cur.chatPath === "string" ? normalizeEndpointPath(cur.chatPath) : "") : cleanChatPath;
+  if (!cleanUrl && !cleanKeys.length && !finalAllowed.length && !finalAuths.length && !finalModelsPath && !finalChatPath) {
+    delete configs[id];
+  } else {
+    configs[id] = { baseUrl: cleanUrl, keys: cleanKeys };
+    if (finalAuths.length) configs[id].auths = finalAuths;
+    if (finalAllowed.length) configs[id].allowedModels = finalAllowed;
+    if (finalModelsPath) configs[id].modelsPath = finalModelsPath;
+    if (finalChatPath) configs[id].chatPath = finalChatPath;
+  }
+  const oldKeys = readState(file).providerKeys;
+  if (oldKeys && typeof oldKeys === "object" && oldKeys[id] !== undefined) {
+    const nextKeys = { ...oldKeys };
+    delete nextKeys[id];
+    writeStateImmediate(file, { providerKeys: nextKeys, providerConfigs: configs });
+    return { baseUrl: cleanUrl, keys: cleanKeys, auths: finalAuths, allowedModels: finalAllowed, modelsPath: finalModelsPath, chatPath: finalChatPath };
+  }
+  writeStateImmediate(file, { providerConfigs: configs });
+  return { baseUrl: cleanUrl, keys: cleanKeys, auths: finalAuths, allowedModels: finalAllowed, modelsPath: finalModelsPath, chatPath: finalChatPath };
+}

package/src/state/schemas/token.js

@@ -0,0 +1,43 @@
+import { mkdirSync, readFileSync, writeFileSync, existsSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+import { defaultStateFile, tokenFile, generateToken, readState, writeStateImmediate, getEntry } from "../store.js";
+
+function syncTokenFile(token, file) {
+  try {
+    const tf = tokenFile(file);
+    mkdirSync(dirname(tf), { recursive: true });
+    writeFileSync(tf, String(token || "").trim() + "\n", "utf8");
+  } catch {}
+}
+
+export async function loadToken({ file = defaultStateFile() } = {}) {
+  const state = readState(file);
+  if (typeof state.token === "string" && state.token.length > 0) {
+    syncTokenFile(state.token, file);
+    return { token: state.token, created: false };
+  }
+  if (existsSync(file)) {
+    try {
+      const raw = JSON.parse(readFileSync(file, "utf8"));
+      if (typeof raw.token === "string" && raw.token.length > 0) {
+        syncTokenFile(raw.token, file);
+        const e = getEntry(file);
+        e.data = raw;
+        try { e.mtimeMs = statSync(file).mtimeMs; } catch {}
+        return { token: raw.token, created: false };
+      }
+    } catch {}
+  }
+  const tok = generateToken();
+  const saved = writeStateImmediate(file, { token: tok, createdAt: new Date().toISOString() }).token;
+  syncTokenFile(saved, file);
+  return { token: saved, created: true };
+}
+
+export async function refreshToken({ file = defaultStateFile() } = {}) {
+  const tok = writeStateImmediate(file, { token: generateToken(), createdAt: new Date().toISOString() }).token;
+  syncTokenFile(tok, file);
+  return tok;
+}
+
+export { generateToken, tokenFile };

package/src/state/store.js

@@ -0,0 +1,202 @@
+import { randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync, statSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import os from "node:os";
+import { loadFromDisk, atomicWriteSync, getMtimeMs, ensureDir } from "./persist.js";
+
+export const DEFAULT_PORT = 8989;
+
+function isTestEnv() {
+  if (process.env.NODE_ENV === "test") return true;
+  if (process.env.MSLXDFF_STATE_FILE && String(process.env.MSLXDFF_STATE_FILE).includes("mslxdff-test")) return true;
+  if (process.argv.some((a) => String(a).includes("--test") || String(a).endsWith(".test.js"))) return true;
+  if (Array.isArray(process.execArgv) && process.execArgv.some((a) => String(a).includes("--test"))) return true;
+  if (process.env.NODE_TEST_CONTEXT) return true;
+  return false;
+}
+
+export function defaultStateFile() {
+  if (process.env.MSLXDFF_STATE_FILE) return process.env.MSLXDFF_STATE_FILE;
+  if (isTestEnv()) return join(os.tmpdir(), "mslxdff-test-state.json");
+  return join(os.homedir(), ".config", "mslxdff", "state.json");
+}
+
+export function tokenFile(file) {
+  if (process.env.MSLXDFF_TOKEN_FILE) return process.env.MSLXDFF_TOKEN_FILE;
+  const sf = file || defaultStateFile();
+  const realDefault = join(os.homedir(), ".config", "mslxdff", "state.json");
+  if (sf !== realDefault) return join(dirname(sf), "token");
+  if (isTestEnv()) return join(os.tmpdir(), "mslxdff-test-token");
+  return join(os.homedir(), ".config", "mslxdff", "token");
+}
+
+export function generateToken() {
+  return randomBytes(32).toString("hex");
+}
+
+// ---- 缓存层：读走内存，写分“热/冷”两档，热数据 500ms 批量刷盘 ----
+const stateCache = new Map(); // file -> { data, dirty, timer, mtimeMs }
+const FLUSH_MS = (() => {
+  const n = Number(process.env.MSLXDFF_STATE_FLUSH_MS);
+  return Number.isInteger(n) && n >= 0 ? n : 500;
+})();
+
+function getEntry(file) {
+  let e = stateCache.get(file);
+  if (!e) {
+    e = { data: null, dirty: false, timer: null, mtimeMs: 0 };
+    stateCache.set(file, e);
+  }
+  return e;
+}
+
+// ---- 合并规则：coldWins 以 disk 为准，hotWins 以 mem 为准 ----
+const COLD_WINS = new Set([
+  "providerConfigs",
+  "providerKeys",
+  "providerShareKeys",
+  "port",
+  "token",
+  "preferredModel",
+  "modelPicks",
+  "peers",
+  "groups",
+  "groupsJoined",
+  "bans",
+  "createdAt",
+]);
+
+function mergeState(disk, mem) {
+  const merged = { ...disk, ...mem };
+  for (const k of COLD_WINS) {
+    if (disk[k] !== undefined) merged[k] = disk[k];
+    else if (!(k in disk) && k in mem) {
+      // deletion on disk: respect deletion by removing from merged if disk intentionally lacks key?
+      // Preserve original behavior: keep mem's stale value (do not delete).
+      // Uncomment to support true deletion: delete merged[k];
+    }
+  }
+  return merged;
+}
+
+function readState(file) {
+  const e = getEntry(file);
+  if (e.data !== null) {
+    try {
+      const st = statSync(file);
+      if (st.mtimeMs === e.mtimeMs) return e.data;
+      if (e.dirty) {
+        const disk = loadFromDisk(file);
+        const diskObj = typeof disk === "object" && disk !== null ? disk : {};
+        const merged = mergeState(diskObj, e.data);
+        e.data = merged;
+        e.mtimeMs = st.mtimeMs;
+        return e.data;
+      }
+    } catch {
+      if (e.data) return e.data;
+    }
+  }
+  const disk = loadFromDisk(file);
+  const obj = typeof disk === "object" && disk !== null ? disk : {};
+  e.data = obj;
+  try {
+    const st = statSync(file);
+    e.mtimeMs = st.mtimeMs;
+  } catch {
+    e.mtimeMs = Date.now();
+  }
+  e.dirty = false;
+  return e.data;
+}
+
+function writeStateImmediate(file, patch) {
+  const e = getEntry(file);
+  const base = e.data !== null ? e.data : readState(file);
+  const merged = { ...base, ...patch };
+  e.data = merged;
+  e.dirty = false;
+  if (e.timer) {
+    clearTimeout(e.timer);
+    e.timer = null;
+  }
+  ensureDir(file);
+  const mtime = atomicWriteSync(file, merged);
+  e.mtimeMs = mtime;
+  return merged;
+}
+
+function scheduleFlush(file) {
+  const e = getEntry(file);
+  if (e.timer) return;
+  if (FLUSH_MS === 0) {
+    flushStateSync(file);
+    return;
+  }
+  e.timer = setTimeout(() => {
+    e.timer = null;
+    void flushState(file);
+  }, FLUSH_MS);
+  e.timer.unref?.();
+}
+
+async function flushState(file) {
+  const e = stateCache.get(file);
+  if (!e || !e.dirty || !e.data) return;
+  const snapshot = e.data;
+  try {
+    ensureDir(file);
+    const mtime = await atomicWriteAsync(file, snapshot);
+    e.dirty = false;
+    e.mtimeMs = mtime;
+  } catch {
+    // retain dirty
+  }
+}
+
+function writeStateDeferred(file, patch) {
+  const e = getEntry(file);
+  const base = e.data !== null ? e.data : readState(file);
+  const merged = { ...base, ...patch };
+  e.data = merged;
+  e.dirty = true;
+  scheduleFlush(file);
+  return merged;
+}
+
+export function flushStateSync(file = defaultStateFile()) {
+  const e = stateCache.get(file);
+  if (!e || !e.dirty || !e.data) return;
+  try {
+    ensureDir(file);
+    const mtime = atomicWriteSync(file, e.data);
+    e.dirty = false;
+    e.mtimeMs = mtime;
+    if (e.timer) {
+      clearTimeout(e.timer);
+      e.timer = null;
+    }
+  } catch {}
+}
+
+export function clearStateCache(file) {
+  if (file) stateCache.delete(file);
+  else stateCache.clear();
+}
+
+// internal helper for facade compat
+function writeState(file, patch) {
+  return writeStateImmediate(file, patch);
+}
+
+export {
+  readState,
+  writeStateImmediate,
+  writeStateDeferred,
+  scheduleFlush,
+  flushState,
+  writeState,
+  getEntry,
+  stateCache,
+};