mslxdff 0.1.64 → 0.1.66

package/src/state/memory.js

@@ -0,0 +1,180 @@
+/**
+ * memory Store adapter — 零 IO 的 Store 第二实现，证明 Store seam 真实。
+ * 与 fileStore（src/state/store.js）共享同一 merge 语义与冷/热分层，
+ * 仅将 persist 层替换为 Map<file, {json, mtimeMs}>，不触 `node:fs`。
+ * 用于 `—test-concurrency>1` 并行与单测快速路径。
+ */
+const memCache = new Map(); // file -> { data, dirty, timer, mtimeMs }
+const memDisk = new Map(); // file -> { obj, mtimeMs }
+
+function getEntry(file) {
+  let e = memCache.get(file);
+  if (!e) {
+    e = { data: null, dirty: false, timer: null, mtimeMs: 0 };
+    memCache.set(file, e);
+  }
+  return e;
+}
+
+function loadFromDiskMem(file) {
+  const v = memDisk.get(file);
+  return v ? structuredClone(v.obj) : {};
+}
+function getMtimeMem(file) {
+  const v = memDisk.get(file);
+  return v ? v.mtimeMs : 0;
+}
+function atomicWriteSyncMem(file, data) {
+  const now = Date.now();
+  // ensure monotonic mtime
+  const prev = memDisk.get(file)?.mtimeMs || 0;
+  const mtime = now <= prev ? prev + 1 : now;
+  memDisk.set(file, { obj: structuredClone(data), mtimeMs: mtime });
+  return mtime;
+}
+
+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];
+  return merged;
+}
+
+function readState(file) {
+  const e = getEntry(file);
+  if (e.data !== null) {
+    const mtime = getMtimeMem(file);
+    if (mtime === e.mtimeMs) return e.data;
+    if (e.dirty) {
+      const disk = loadFromDiskMem(file);
+      const merged = mergeState(disk || {}, e.data);
+      e.data = merged;
+      e.mtimeMs = mtime;
+      return e.data;
+    }
+  }
+  const disk = loadFromDiskMem(file);
+  e.data = disk && typeof disk === "object" ? structuredClone(disk) : {};
+  e.mtimeMs = getMtimeMem(file) || 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; }
+  e.mtimeMs = atomicWriteSyncMem(file, merged);
+  return merged;
+}
+
+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;
+  // 内存版无需定时刷盘，延迟写即 dirty，下次 flush 或 read 时合并
+  return merged;
+}
+
+export function flushStateSync(file) {
+  const e = memCache.get(file);
+  if (!e || !e.dirty || !e.data) return;
+  e.mtimeMs = atomicWriteSyncMem(file || "mem://default", e.data);
+  e.dirty = false;
+  if (e.timer) { clearTimeout(e.timer); e.timer = null; }
+}
+
+export function clearStateCache(file) {
+  if (file) memCache.delete(file);
+  else memCache.clear();
+}
+
+// ---- domain 工厂（复用 schemas 的 normalize 逻辑，但闭包于 memory store） ----
+// 为保持零依赖，memory 侧直接内联必要的 normalize（如 normalizeAllowedModel）
+// 此处仅暴露与 fileStore 对等的最小子集用于测试 seam；完整 facade 可按需扩展
+
+const WORKBUDDY_DEFAULT_BASE_URL = "https://copilot.tencent.com";
+function normalizeAllowedModel(model, providerId) {
+  let s = String(model || "").trim();
+  if (!s) return "";
+  const idx = s.indexOf("/");
+  if (idx > 0 && s.slice(0, idx).toLowerCase() === String(providerId || "").toLowerCase()) s = s.slice(idx + 1);
+  return s;
+}
+function defaultStateFileMem(file) { return file || "mem://default"; }
+
+export function createMemoryState(file = "mem://default") {
+  const f = defaultStateFileMem(file);
+  return {
+    loadModelErrors: () => {
+      const v = readState(f).modelErrors;
+      return v && typeof v === "object" && !Array.isArray(v) ? structuredClone(v) : {};
+    },
+    saveModelErrors: (errors) => { writeStateDeferred(f, { modelErrors: structuredClone(errors) }); return errors; },
+    loadModelLatencies: () => {
+      const v = readState(f).modelLatencies;
+      return v && typeof v === "object" && !Array.isArray(v) ? structuredClone(v) : {};
+    },
+    saveModelLatencies: (v) => { writeStateDeferred(f, { modelLatencies: structuredClone(v) }); return v; },
+    loadProviderKeys: (id) => {
+      const keys = readState(f).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 [];
+    },
+    saveProviderKeys: (id, list) => {
+      const keys = { ...(readState(f).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(f, { providerKeys: keys });
+      return clean;
+    },
+    loadProviderAllowedModels: (id) => {
+      const cfg = readState(f).providerConfigs?.[id];
+      if (cfg && Array.isArray(cfg.allowedModels)) return [...cfg.allowedModels].map((m) => normalizeAllowedModel(m, id)).filter(Boolean);
+      return [];
+    },
+    saveProviderAllowedModels: (id, list) => {
+      const clean = [...new Set((Array.isArray(list) ? list : []).map((m) => normalizeAllowedModel(m, id)).filter(Boolean))];
+      const configs = { ...(readState(f).providerConfigs || {}) };
+      const cur = configs[id] || {};
+      configs[id] = { ...cur, allowedModels: clean };
+      if (!clean.length) delete configs[id].allowedModels;
+      if (!configs[id].baseUrl && !(configs[id].keys||[]).length && !(configs[id].allowedModels||[]).length) delete configs[id];
+      writeStateImmediate(f, { providerConfigs: configs });
+      return clean;
+    },
+    loadPeers: () => {
+      const v = readState(f).peers;
+      return Array.isArray(v) ? structuredClone(v) : [];
+    },
+    savePeers: (peers) => { writeStateImmediate(f, { peers: structuredClone(peers) }); return peers; },
+    flushSync: () => flushStateSync(f),
+    clear: () => clearStateCache(f),
+    _memDisk: memDisk,
+    _memCache: memCache,
+  };
+}
+
+// 单例 memory facade（便于直接 import 使用）
+export const memoryState = createMemoryState("mem://default");

package/src/state/persist.js

@@ -0,0 +1,42 @@
+import { mkdirSync, readFileSync, writeFileSync, statSync, renameSync, unlinkSync } from "node:fs";
+import { writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export function loadFromDisk(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+export function ensureDir(file) {
+  mkdirSync(dirname(file), { recursive: true });
+}
+
+export function getMtimeMs(file) {
+  try {
+    return statSync(file).mtimeMs;
+  } catch {
+    return Date.now();
+  }
+}
+
+export function atomicWriteSync(file, data) {
+  ensureDir(file);
+  const tmp = `${file}.tmp.${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2), { mode: 0o600 });
+  try {
+    renameSync(tmp, file);
+  } catch {
+    try { writeFileSync(file, JSON.stringify(data, null, 2), { mode: 0o600 }); } catch {}
+    try { unlinkSync(tmp); } catch {}
+  }
+  return getMtimeMs(file);
+}
+
+export async function atomicWriteAsync(file, data) {
+  ensureDir(file);
+  await writeFile(file, JSON.stringify(data, null, 2), { mode: 0o600 });
+  return getMtimeMs(file);
+}

package/src/state/schemas/allowlist.js

@@ -0,0 +1,87 @@
+import { defaultStateFile, readState, writeStateImmediate } from "../store.js";
+import {
+  normalizeAllowedModel,
+  normalizeBaseUrl,
+  normalizeAuths,
+  normalizeEndpointPath,
+  loadProviderConfigs,
+  loadProviderConfig,
+  loadProviderBaseUrl,
+  loadProviderKeys,
+} from "./provider.js";
+
+export function loadProviderAllowedModels(id, { file = defaultStateFile() } = {}) {
+  const cfg = loadProviderConfig(id, { file });
+  if (cfg && Array.isArray(cfg.allowedModels)) return [...cfg.allowedModels];
+  const raw = readState(file).providerConfigs?.[id];
+  if (raw && Array.isArray(raw.allowedModels)) return [...new Set(raw.allowedModels.map((m) => normalizeAllowedModel(m, id)).filter(Boolean))];
+  return [];
+}
+
+export function saveProviderAllowedModels(id, list, { file = defaultStateFile() } = {}) {
+  const clean = [...new Set((Array.isArray(list) ? list : []).map((m) => normalizeAllowedModel(m, id)).filter(Boolean))];
+  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) ? cur.keys : loadProviderKeys(id, { file });
+  const auths = normalizeAuths(cur.auths);
+  const modelsPath = typeof cur.modelsPath === "string" ? normalizeEndpointPath(cur.modelsPath) : "";
+  const chatPath = typeof cur.chatPath === "string" ? normalizeEndpointPath(cur.chatPath) : "";
+  if (!baseUrl && !keys.length && !auths.length && !clean.length && !modelsPath && !chatPath) {
+    delete configs[id];
+  } else {
+    configs[id] = { baseUrl, keys };
+    if (auths.length) configs[id].auths = auths;
+    if (clean.length) configs[id].allowedModels = clean;
+    if (modelsPath) configs[id].modelsPath = modelsPath;
+    if (chatPath) configs[id].chatPath = chatPath;
+  }
+  writeStateImmediate(file, { providerConfigs: configs });
+  return clean;
+}
+
+export function addProviderAllowedModel(id, model, opts = {}) {
+  const cur = loadProviderAllowedModels(id, opts);
+  const norm = normalizeAllowedModel(model, id);
+  if (!norm || cur.includes(norm)) return cur;
+  return saveProviderAllowedModels(id, [...cur, norm], opts);
+}
+
+export function removeProviderAllowedModel(id, model, opts = {}) {
+  return removeProviderAllowedModels(id, [model], opts);
+}
+
+export function removeProviderAllowedModels(id, targets = [], opts = {}) {
+  const set = new Set((Array.isArray(targets) ? targets : [targets]).map((m) => normalizeAllowedModel(m, id)).filter(Boolean));
+  const cur = loadProviderAllowedModels(id, opts);
+  const next = cur.filter((m) => !set.has(m));
+  return saveProviderAllowedModels(id, next, opts);
+}
+
+function normalizeAllowAny(v, id) {
+  if (typeof v === "boolean") return v;
+  if (String(id || "").toLowerCase() === "opencode") return true;
+  return false;
+}
+export function loadProviderAllowAnyModels(id, { file = defaultStateFile() } = {}) {
+  const cfg = readState(file).providerConfigs?.[id];
+  if (cfg && typeof cfg.allowAnyModels === "boolean") return cfg.allowAnyModels;
+  return normalizeAllowAny(undefined, id);
+}
+export function saveProviderAllowAnyModels(id, allowAny, { file = defaultStateFile() } = {}) {
+  const state = readState(file);
+  const cfgs = { ...(state.providerConfigs || {}) };
+  const cur = cfgs[id] || {};
+  cfgs[id] = { ...cur, allowAnyModels: normalizeAllowAny(allowAny, id) };
+  writeStateImmediate(file, { providerConfigs: cfgs });
+  return cfgs[id].allowAnyModels;
+}
+export function isModelAllowed(id, rawModel, { file = defaultStateFile() } = {}) {
+  const raw = String(rawModel || "").trim();
+  if (!raw) return true;
+  const allowed = loadProviderAllowedModels(id, { file });
+  const allowAny = loadProviderAllowAnyModels(id, { file });
+  if (!allowed.length) return allowAny;
+  const norm = normalizeAllowedModel(raw, id);
+  return allowed.includes(norm);
+}

package/src/state/schemas/group.js

@@ -0,0 +1,31 @@
+import { defaultStateFile, readState, writeStateImmediate } from "../store.js";
+
+export function loadGroups({ file = defaultStateFile() } = {}) {
+  const groups = readState(file).groups;
+  return groups && typeof groups === "object" && !Array.isArray(groups) ? groups : {};
+}
+
+export function loadGroupsJoined({ file = defaultStateFile() } = {}) {
+  const joined = readState(file).groupsJoined;
+  return Array.isArray(joined) ? joined : [];
+}
+
+export function saveGroupsJoined(joined, { file = defaultStateFile() } = {}) {
+  writeStateImmediate(file, { groupsJoined: joined });
+  return joined;
+}
+
+export function loadBans({ file = defaultStateFile() } = {}) {
+  const bans = readState(file).bans;
+  return bans && typeof bans === "object" && !Array.isArray(bans) ? bans : {};
+}
+
+export function saveBans(bans, { file = defaultStateFile() } = {}) {
+  writeStateImmediate(file, { bans });
+  return bans;
+}
+
+export function saveGroups(groups, { file = defaultStateFile() } = {}) {
+  writeStateImmediate(file, { groups });
+  return groups;
+}

package/src/state/schemas/model.js

@@ -0,0 +1,53 @@
+import { defaultStateFile, readState, writeStateImmediate, writeStateDeferred } from "../store.js";
+
+export function loadModelErrors({ file = defaultStateFile() } = {}) {
+  const errors = readState(file).modelErrors;
+  return errors && typeof errors === "object" && !Array.isArray(errors) ? errors : {};
+}
+
+export function saveModelErrors(errors, { file = defaultStateFile() } = {}) {
+  writeStateDeferred(file, { modelErrors: errors });
+  return errors;
+}
+
+export function loadModelLatencies({ file = defaultStateFile() } = {}) {
+  const lat = readState(file).modelLatencies;
+  return lat && typeof lat === "object" && !Array.isArray(lat) ? lat : {};
+}
+
+export function saveModelLatencies(latencies, { file = defaultStateFile() } = {}) {
+  writeStateDeferred(file, { modelLatencies: latencies });
+  return latencies;
+}
+
+export function loadModelStats({ file = defaultStateFile() } = {}) {
+  const s = readState(file).modelStats;
+  return s && typeof s === "object" && !Array.isArray(s) ? s : {};
+}
+
+export function saveModelStats(stats, { file = defaultStateFile() } = {}) {
+  writeStateDeferred(file, { modelStats: stats });
+  return stats;
+}
+
+export function loadPreferredModel({ file = defaultStateFile() } = {}) {
+  const v = readState(file).preferredModel;
+  return typeof v === "string" && v.trim() ? v.trim() : null;
+}
+
+export function loadModelPicks({ file = defaultStateFile() } = {}) {
+  const picks = readState(file).modelPicks;
+  if (!Array.isArray(picks)) return [];
+  return [...new Set(picks.filter((x) => typeof x === "string" && x.trim().length))];
+}
+
+export function saveModelPicks(picks, { file = defaultStateFile() } = {}) {
+  const list = [...new Set((Array.isArray(picks) ? picks : []).filter((x) => typeof x === "string" && x.trim().length))];
+  writeStateImmediate(file, { modelPicks: list });
+  return list;
+}
+
+export function savePreferredModel(id, { file = defaultStateFile() } = {}) {
+  writeStateImmediate(file, { preferredModel: String(id || "").trim() });
+  return String(id || "").trim();
+}

package/src/state/schemas/peer.js

@@ -0,0 +1,31 @@
+import { defaultStateFile, readState, writeStateImmediate, writeStateDeferred } from "../store.js";
+
+export function loadPeers({ file = defaultStateFile() } = {}) {
+  const peers = readState(file).peers;
+  return Array.isArray(peers) ? peers : [];
+}
+
+export function savePeers(peers, { file = defaultStateFile() } = {}) {
+  writeStateImmediate(file, { peers });
+  return peers;
+}
+
+export function loadPeerErrors({ file = defaultStateFile() } = {}) {
+  const errors = readState(file).peerErrors;
+  return errors && typeof errors === "object" && !Array.isArray(errors) ? errors : {};
+}
+
+export function savePeerErrors(errors, { file = defaultStateFile() } = {}) {
+  writeStateDeferred(file, { peerErrors: errors });
+  return errors;
+}
+
+export function loadPeerStats({ file = defaultStateFile() } = {}) {
+  const stats = readState(file).peerStats;
+  return stats && typeof stats === "object" && !Array.isArray(stats) ? stats : {};
+}
+
+export function savePeerStats(stats, { file = defaultStateFile() } = {}) {
+  writeStateDeferred(file, { peerStats: stats });
+  return stats;
+}

package/src/state/schemas/port.js

@@ -0,0 +1,10 @@
+import { defaultStateFile, readState, writeStateImmediate } from "../store.js";
+
+export function setPort(port, { file = defaultStateFile() } = {}) {
+  writeStateImmediate(file, { port: Number(port) });
+}
+
+export function getPort({ file = defaultStateFile() } = {}) {
+  const port = readState(file).port;
+  return typeof port === "number" && Number.isInteger(port) && port > 0 ? port : null;
+}