mslxdff 0.1.65 → 0.1.67

package/src/state/memory.js

@@ -0,0 +1,161 @@
+/**
+ * memory Store adapter — 零 IO 的 Store 第二实现，证明 Store seam 真实。
+ * 与 fileStore（src/state/store.js）共享同一 merge 语义与冷/热分层，
+ * 仅将 persist 层替换为 Map<file, {json, mtimeMs}>，不触 `node:fs`。
+ * 用于 `—test-concurrency>1` 并行与单测快速路径。
+ */
+import { mergeState, COLD_WINS } from "./merge.js";
+
+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;
+}
+
+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/merge.js

@@ -0,0 +1,26 @@
+/**
+ * merge 深模块：COLD_WINS + mergeState 纯函数
+ * 供 store.js 与 memory.js 同源，避免复制
+ */
+export const COLD_WINS = new Set([
+  "providerConfigs",
+  "providerKeys",
+  "providerShareKeys",
+  "port",
+  "token",
+  "preferredModel",
+  "modelPicks",
+  "peers",
+  "groups",
+  "groupsJoined",
+  "bans",
+  "createdAt",
+]);
+
+export function mergeState(disk, mem) {
+  const merged = { ...disk, ...mem };
+  for (const k of COLD_WINS) {
+    if (disk[k] !== undefined) merged[k] = disk[k];
+  }
+  return merged;
+}

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/provider-config.js

@@ -0,0 +1,143 @@
+/**
+ * ProviderConfig 深模块：7 字段 validate/normalize/merge 单点
+ * 纯函数，不读 env/file，直接由调用方注入三级数据
+ */
+
+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 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`;
+
+/**
+ * validate 7 字段：baseUrl, keys, auths, allowedModels, modelsPath, chatPath, shareKeys?（share 单独）
+ * 返回 {ok, clean, errors}
+ */
+export function validateProviderConfig(raw = {}, providerId = "") {
+  const errors = [];
+  const clean = {};
+  // baseUrl
+  const baseUrl = normalizeBaseUrl(raw.baseUrl);
+  if (raw.baseUrl !== undefined && raw.baseUrl !== null && String(raw.baseUrl).trim() && !baseUrl) errors.push("baseUrl 不能为空");
+  clean.baseUrl = baseUrl;
+  // keys
+  const keys = [...new Set((Array.isArray(raw.keys) ? raw.keys : []).map((k) => String(k || "").trim()).filter(Boolean))];
+  clean.keys = keys;
+  // auths
+  clean.auths = normalizeAuths(raw.auths);
+  // allowedModels
+  const allowed = [...new Set((Array.isArray(raw.allowedModels) ? raw.allowedModels : []).map((m) => normalizeAllowedModel(m, providerId)).filter(Boolean))];
+  clean.allowedModels = allowed;
+  // modelsPath / chatPath
+  clean.modelsPath = raw.modelsPath === undefined ? undefined : (String(raw.modelsPath).trim() ? normalizeEndpointPath(raw.modelsPath) : "");
+  clean.chatPath = raw.chatPath === undefined ? undefined : (String(raw.chatPath).trim() ? normalizeEndpointPath(raw.chatPath) : "");
+  // 若 baseUrl 非空但不是 url 形态，弱校验：必须含 . 或 ://
+  if (clean.baseUrl && !/^https?:\/\//.test(clean.baseUrl) && !clean.baseUrl.includes(".")) {
+    // workbuddy 默认 https 已过，此分支仅防空
+  }
+  return { ok: errors.length === 0, clean, errors };
+}
+
+/**
+ * normalize 保持与 validate 一致，但不返回 ok，直接回 clean（用于落盘前归一）
+ */
+export function normalizeProviderConfig(raw = {}, providerId = "") {
+  const { clean } = validateProviderConfig(raw, providerId);
+  return clean;
+}
+
+/**
+ * merge 三级：env > file > legacy
+ * env: {baseUrl, keys} 来自 process.env
+ * file: 来自 providerConfigs[id]
+ * legacy: 来自 providerKeys[id]（字符串或数组）
+ */
+export function mergeProviderConfig({ env = {}, file = {}, legacy = [] } = {}, providerId = "") {
+  // env 优先
+  const envKeys = Array.isArray(env.keys) ? [...new Set(env.keys.filter(Boolean))] : [];
+  const hasEnv = !!(env.baseUrl || envKeys.length);
+  if (hasEnv) {
+    return {
+      baseUrl: normalizeBaseUrl(env.baseUrl || file.baseUrl || ""),
+      keys: envKeys.length ? envKeys : (Array.isArray(file.keys) ? file.keys : []),
+      // env 模式下 file 的 allowed/auths 仍透传（与原 loadProviderConfig 一致）
+      allowedModels: Array.isArray(file.allowedModels) ? [...new Set(file.allowedModels.map((m) => normalizeAllowedModel(m, providerId)).filter(Boolean))] : [],
+      auths: normalizeAuths(file.auths),
+      modelsPath: file.modelsPath ? normalizeEndpointPath(file.modelsPath) : defaultModelsPath(providerId),
+      chatPath: file.chatPath ? normalizeEndpointPath(file.chatPath) : defaultChatPath(providerId),
+    };
+  }
+  // file 优先
+  if (file && typeof file === "object" && (file.baseUrl || (Array.isArray(file.keys) && file.keys.length) || file.allowedModels || file.auths)) {
+    return {
+      baseUrl: normalizeBaseUrl(file.baseUrl || ""),
+      keys: Array.isArray(file.keys) ? [...new Set(file.keys.filter(Boolean))] : [],
+      allowedModels: Array.isArray(file.allowedModels) ? [...new Set(file.allowedModels.map((m) => normalizeAllowedModel(m, providerId)).filter(Boolean))] : [],
+      auths: normalizeAuths(file.auths),
+      modelsPath: file.modelsPath ? normalizeEndpointPath(file.modelsPath) : defaultModelsPath(providerId),
+      chatPath: file.chatPath ? normalizeEndpointPath(file.chatPath) : defaultChatPath(providerId),
+    };
+  }
+  // legacy
+  const legacyKeys = Array.isArray(legacy) ? [...new Set(legacy.filter((k) => typeof k === "string" && k.trim().length))] : (typeof legacy === "string" && legacy.trim() ? [legacy.trim()] : []);
+  if (legacyKeys.length) {
+    return {
+      baseUrl: String(providerId).toLowerCase() === "workbuddy" ? WORKBUDDY_DEFAULT_BASE_URL : "",
+      keys: legacyKeys,
+      allowedModels: [],
+      auths: [],
+      modelsPath: defaultModelsPath(providerId),
+      chatPath: defaultChatPath(providerId),
+    };
+  }
+  return { baseUrl: "", keys: [], allowedModels: [], auths: [], modelsPath: defaultModelsPath(providerId), chatPath: defaultChatPath(providerId) };
+}

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;
+}