@mokuyoaxis/dsh-iris 0.1.0

package/lib/config.js

@@ -0,0 +1,384 @@
+'use strict';
+/**
+ * Iris 配置存储：$DSH_HOME/iris/v1/providers.json
+ * 结构与 ai-paint 工作台兼容（providers 数组同形），支持一键导入。
+ * Key 明文落盘（0600）；接口层永远不回明文。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import * as cap from './capability.js';
+import * as models from './models.js';
+
+export function irisHome() {
+  const home = process.env.DSH_HOME || path.join(os.homedir(), '.dsh');
+  return path.join(home, 'iris', 'v1');
+}
+
+function storeFile() {
+  return path.join(irisHome(), 'providers.json');
+}
+
+let cache = null;
+
+/* ---------------- 状态变化总线（阶段 4 SSE：供应商/分配落盘即通知） ---------------- */
+const changeListeners = new Set();
+/** 订阅配置变化（upsert/remove/assignment 都会触发）；返回退订函数 */
+export function onChange(fn) {
+  changeListeners.add(fn);
+  return () => changeListeners.delete(fn);
+}
+function emitChange() {
+  for (const fn of [...changeListeners]) {
+    try { fn(); } catch (_) { /* 单个监听者异常不影响其余 */ }
+  }
+}
+
+function persist() {
+  fs.mkdirSync(path.dirname(storeFile()), { recursive: true });
+  const tmp = storeFile() + '.tmp';
+  // 0600 从创建时生效（含临时文件）；rename 保留 mode，chmod 兜底不依赖 umask
+  fs.writeFileSync(tmp, JSON.stringify(cache, null, 2), { mode: 0o600 });
+  fs.renameSync(tmp, storeFile());
+  try {
+    fs.chmodSync(storeFile(), 0o600);
+  } catch (_) {
+    /* ignore */
+  }
+  emitChange(); // 任何配置落盘 = 状态变了 → SSE 推送
+}
+
+export function load() {
+  if (cache) return cache;
+  const file = storeFile();
+  if (!fs.existsSync(file)) {
+    // 文件不存在 = 首次运行，正常初始化
+    cache = { version: 1, providers: [], assignments: {} };
+    persist();
+    return cache;
+  }
+  try {
+    cache = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!Array.isArray(cache.providers)) cache.providers = [];
+    if (!cache.assignments || typeof cache.assignments !== 'object') cache.assignments = {};
+  } catch (err) {
+    // 文件存在但损坏：隔离，绝不静默覆盖证据
+    const backup = file + '.corrupted-' + Date.now();
+    try {
+      fs.renameSync(file, backup);
+    } catch (_) {
+      /* 隔离失败也继续 */
+    }
+    console.error('[iris] providers.json 已损坏，已隔离为 ' + backup + '：', err && err.message);
+    cache = { version: 1, providers: [], assignments: {} };
+    persist();
+  }
+  return cache;
+}
+
+/** 测试/重载用：丢弃内存缓存，下次读取重新走盘 */
+export function resetCache() {
+  cache = null;
+}
+
+/** 首次运行且 Iris 为空时，从工作台配置导入（迁移动作，非耦合） */
+export function importFromWorkbench(workbenchConfigPath) {
+  const c = load();
+  if (c.providers.length) return { imported: 0, reason: '已有配置，跳过导入' };
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(workbenchConfigPath, 'utf8'));
+  } catch (_) {
+    return { imported: 0, reason: '未找到工作台配置' };
+  }
+  const list = Array.isArray(raw.providers) ? raw.providers : [];
+  let n = 0;
+  for (const p of list) {
+    if (!p || !p.apiKey || !p.baseUrl) continue;
+    c.providers.push({
+      id: 'iris_' + Math.random().toString(36).slice(2, 8),
+      name: p.name || p.id,
+      type: p.type === 'anthropic' ? 'anthropic' : 'openai',
+      baseUrl: p.baseUrl,
+      apiKey: p.apiKey,
+      enabled: p.enabled !== false,
+      // 媒体生成默认走百炼协议；OpenAI Images 兼容后端由用户按需切换
+      mediaProtocol: /dashscope/i.test(p.baseUrl) ? 'dashscope' : 'openai-images'
+    });
+    n++;
+  }
+  if (n) persist();
+  return { imported: n };
+}
+
+export function providers() {
+  return load().providers.filter((p) => p.enabled && p.apiKey);
+}
+
+export function providerById(id) {
+  return providers().find((p) => p.id === id);
+}
+
+/** 能力 → 该能力在 provider 上对应的模型字段（models.CAP_FIELD 别名） */
+const FIELD_OF = models.CAP_FIELD;
+
+/**
+ * 严格选择（阶段 6 模型池）：优先用「已分配模型」（有序列表取第一个可用），
+ * 否则从全局模型池挑第一个有能力标签的模型。
+ * 返回该模型所属 provider 的副本，并把该能力的模型字段设为选中模型。
+ * 向后兼容：调用方继续读 provider.apiKey / provider.imageModel 等。
+ * 无可用模型 → null（不再兜底到任意 provider）。
+ */
+export function pickFor(capability) {
+  const pool = models.modelPool(providers());
+  let m = null;
+  for (const ref of assignmentOrder(capability)) {
+    m = pool.find((x) => x.ref === ref && x.capabilities.includes(capability));
+    if (m) break;
+  }
+  if (!m) m = models.pickModel(pool, capability);
+  if (!m) return null;
+  const p = providerById(m.providerId);
+  if (!p) return null;
+  const field = FIELD_OF[capability];
+  return field ? { ...p, [field]: m.id } : p;
+}
+
+/**
+ * 同一能力的有序 provider 列表（供 failover 依次尝试）：
+ * 已分配顺序优先（阶段 6 条目 4），其余按池顺序补齐（去重）。
+ * 一个 provider 若池里有多个该能力模型，会返回多条（各自带不同模型）。
+ */
+export function pickAllFor(capability) {
+  const pool = models.modelPool(providers());
+  const chosen = [];
+  const seen = new Set();
+  const add = (m) => {
+    const k = m.providerId + '\u0000' + m.id;
+    if (!seen.has(k)) { seen.add(k); chosen.push(m); }
+  };
+  for (const ref of assignmentOrder(capability)) {
+    for (const m of pool) if (m.ref === ref && m.capabilities.includes(capability)) add(m);
+  }
+  for (const m of pool) if (m.capabilities.includes(capability)) add(m);
+  const out = [];
+  for (const m of chosen) {
+    const p = providerById(m.providerId);
+    if (!p) continue;
+    const field = FIELD_OF[capability];
+    out.push(field ? { ...p, [field]: m.id } : p);
+  }
+  return out;
+}
+
+/** 能力 → 模型复合引用 的分配映射；兼容旧的纯 model id。 */
+export function assignments() {
+  return load().assignments || {};
+}
+
+function resolveAssignment(pool, raw, capability) {
+  let providerId = '';
+  let modelId = '';
+  if (raw && typeof raw === 'object') {
+    providerId = String(raw.providerId || '');
+    modelId = String(raw.modelId || raw.id || '');
+  } else if (typeof raw === 'string') {
+    const parsed = models.parseModelRef(raw);
+    if (parsed) ({ providerId, modelId } = parsed);
+    else modelId = raw; // v1 旧格式：纯 model id，按池顺序取第一个
+  }
+  return pool.find((m) => m.id === modelId
+    && (!providerId || m.providerId === providerId)
+    && m.capabilities.includes(capability)) || null;
+}
+
+/** 归一化某能力的有序分配列表 → [providerId::modelId, ...]。 */
+export function assignmentOrder(capability) {
+  const a = assignments()[capability];
+  if (!a) return [];
+  const pool = models.modelPool(providers());
+  const refs = [];
+  for (const raw of (Array.isArray(a) ? a : [a])) {
+    const m = resolveAssignment(pool, raw, capability);
+    if (m && !refs.includes(m.ref)) refs.push(m.ref);
+  }
+  return refs;
+}
+
+/** 设置某能力分配的模型 id（需在全局池中存在且具备该能力） */
+export function setAssignment(capability, ref) {
+  const c = load();
+  const pool = models.modelPool(providers());
+  const m = resolveAssignment(pool, ref, capability);
+  if (!m) return false;
+  if (!c.assignments) c.assignments = {};
+  c.assignments[capability] = m.ref;
+  persist();
+  return true;
+}
+
+/**
+ * 设置某能力的有序 failover 列表（阶段 6 条目 4）：每个模型须在全局池中存在且具备该能力。
+ * 空数组 = 清除分配（回退池顺序自动选择）。重复 id 自动去重。
+ */
+export function setAssignmentOrder(capability, modelRefs) {
+  const c = load();
+  if (!c.assignments) c.assignments = {};
+  if (!Array.isArray(modelRefs) || !modelRefs.length) {
+    if (c.assignments[capability]) {
+      delete c.assignments[capability];
+      persist();
+    }
+    return true;
+  }
+  const pool = models.modelPool(providers());
+  const refs = [];
+  for (const raw of modelRefs) {
+    const m = resolveAssignment(pool, raw, capability);
+    if (!m) return false;
+    if (!refs.includes(m.ref)) refs.push(m.ref);
+  }
+  if (!refs.length) return false;
+  c.assignments[capability] = refs;
+  persist();
+  return true;
+}
+
+/** 清除某个能力的手动分配（回退到池自动选择） */
+export function clearAssignment(capability) {
+  const c = load();
+  if (c.assignments && c.assignments[capability]) {
+    delete c.assignments[capability];
+    persist();
+  }
+  return true;
+}
+
+/** 某 provider 的模型池覆盖的能力集合（合并各模型的能力标签） */
+export function capabilitiesOf(p) {
+  const caps = new Set();
+  for (const m of models.providerModels(p)) {
+    for (const c of m.capabilities) caps.add(c);
+  }
+  return [...caps];
+}
+
+export function upsert(provider) {
+  const c = load();
+  const { id, ...input } = provider;
+  // PATCH 语义：缺失字段和 undefined 都不覆盖旧值；null/空串仍是显式更新。
+  const rest = Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+  if (id) {
+    const i = c.providers.findIndex((p) => p.id === id);
+    if (i >= 0) {
+      c.providers[i] = { ...c.providers[i], ...rest };
+      persist();
+      return c.providers[i];
+    }
+  }
+  const fresh = { id: 'iris_' + Math.random().toString(36).slice(2, 8), ...rest };
+  c.providers.push(fresh);
+  persist();
+  return fresh;
+}
+
+/** 全部供应商原始记录（含停用，管理 GUI 用） */
+export function allProviders() {
+  return load().providers;
+}
+
+/** 删除一个供应商 */
+export function removeProvider(id) {
+  const c = load();
+  const i = c.providers.findIndex((p) => p.id === id);
+  if (i < 0) return false;
+  c.providers.splice(i, 1);
+  persist();
+  return true;
+}
+
+/** 设置一个供应商的模型池（覆盖显式 models 数组；空数组 = 回退到自动发现/旧字段） */
+export function setProviderModels(id, modelEntries) {
+  const c = load();
+  const p = c.providers.find((x) => x.id === id);
+  if (!p) return null;
+  if (Array.isArray(modelEntries)) {
+    // 保留同名模型已有的 verified/source（重新发现不丢实测结果）
+    const prev = {};
+    for (const m of p.models || []) if (m && m.id) prev[m.id] = m;
+    p.models = modelEntries.map((m) => {
+      const entry = typeof m === 'string' ? { id: m } : { id: m.id, capabilities: m.capabilities };
+      const old = prev[entry.id];
+      if (old) {
+        if (old.verified) entry.verified = old.verified;
+        if (old.source) entry.source = old.source;
+      }
+      if (m && m.verified) entry.verified = m.verified;
+      if (m && m.source) entry.source = m.source;
+      return entry;
+    });
+  }
+  persist();
+  return p;
+}
+
+/** 找 provider 里的某个模型条目（可变引用） */
+function findModelEntry(p, modelId) {
+  return (p.models || []).find((m) => m && m.id === modelId);
+}
+
+/** 手动添加一个模型到池（source=manual，能力由调用方给） */
+export function addProviderModel(id, modelId, capabilities) {
+  const c = load();
+  const p = c.providers.find((x) => x.id === id);
+  if (!p) return null;
+  const name = String(modelId || '').trim();
+  if (!name) return null;
+  if (!Array.isArray(p.models)) p.models = [];
+  let entry = findModelEntry(p, name);
+  if (!entry) {
+    entry = { id: name, capabilities: Array.isArray(capabilities) ? capabilities : [], source: 'manual' };
+    p.models.push(entry);
+  } else if (Array.isArray(capabilities)) {
+    entry.capabilities = capabilities;
+  }
+  persist();
+  return entry;
+}
+
+/** 从池移除一个模型 */
+export function removeProviderModel(id, modelId) {
+  const c = load();
+  const p = c.providers.find((x) => x.id === id);
+  if (!p || !Array.isArray(p.models)) return false;
+  const i = p.models.findIndex((m) => m && m.id === modelId);
+  if (i < 0) return false;
+  p.models.splice(i, 1);
+  persist();
+  return true;
+}
+
+/** 设置某模型的能力标签（用户纠正规则误判 / 给未知模型标能力） */
+export function setModelCapabilities(id, modelId, capabilities) {
+  const c = load();
+  const p = c.providers.find((x) => x.id === id);
+  if (!p) return false;
+  const entry = findModelEntry(p, modelId);
+  if (!entry) return false;
+  entry.capabilities = (Array.isArray(capabilities) ? capabilities : []).filter((x) => cap.isKnownCapability(x));
+  persist();
+  return true;
+}
+
+/** 记录某模型的实测结果（verified[capability] = {ok, at, note}） */
+export function setModelVerified(id, modelId, capability, result) {
+  const c = load();
+  const p = c.providers.find((x) => x.id === id);
+  if (!p) return false;
+  const entry = findModelEntry(p, modelId);
+  if (!entry) return false;
+  if (!entry.verified) entry.verified = {};
+  entry.verified[capability] = { ok: !!result.ok, at: new Date().toISOString(), note: String(result.note || '').slice(0, 200) };
+  persist();
+  return true;
+}

package/lib/guard.js

@@ -0,0 +1,73 @@
+'use strict';
+/**
+ * Iris 请求守卫（O2 授权边界，2026-09-03 修订为"发布安全优先"）。
+ *
+ * 调研宿主结论：DSH 在 `dsh-client-connection` 里有一套权威信任栅栏
+ * `isTrustedApiRequest`（回环∪trustedHosts + Sec-Fetch-Site + Origin==Host），
+ * 但它**只挂在 `/api` 前缀**。iris 注册的是 `/iris/*` 裸 prefix 路由，在栅栏之外，
+ * 所以 iris 需自备一道——但必须**对齐宿主里"永不锁死合法用户"的那半，
+ * 舍弃"会锁死 LAN/反代用户"的那半**。
+ *
+ * 威胁与处置（按发布安全排序）：
+ * ① 驱动式 CSRF（真实、高价值）：恶意网页对 `/iris/api/actions/*` 发跨站 POST，
+ *    触发付费生成/写盘。→ **挡**：POST 时 `Sec-Fetch-Site === cross-site` 拒绝；
+ *    有 `Origin` 且 `Origin.host !== 请求 Host` 拒绝。合法同源用户（不管在回环/LAN/
+ *    反代域名上访问，浏览器 Origin 总与 Host 同源）永不误伤；无 Origin 的 CLI/curl 放行。
+ * ② DNS 重绑定读 state / 驱动 POST（低价值）：需要 Host 白名单才能挡，但白名单正是
+ *    锁死 LAN/反代用户的元凶。用户裁定：iris 开源、反代场景无所谓 → **不挡**，
+ *    读接口（GET/HEAD/SSE）完全放开（跨源读本就受 CORS 阻挡，媒体另有 token 能力凭证）。
+ *
+ * 净效果：**任何部署拓扑都不拦合法用户**，只挡跨站 CSRF 驱动付费动作。
+ */
+
+/** 请求 Host 头 → host:port 规范化（小写，去 IPv6 方括号保留） */
+function authority(header) {
+  const h = String(header || '').trim().toLowerCase();
+  if (!h) return '';
+  return h;
+}
+
+/**
+ * 纯函数裁决：{ok:true} 放行；否则 {ok:false, status, error}。
+ * 非 POST 一律放行；POST 仅挡跨站/跨源（同源浏览器与无 Origin 的 CLI 放行）。
+ * @param {{method?:string, headers?:object}} req node:http IncomingMessage 的最小面
+ */
+export function checkRequest(req) {
+  const headers = req.headers || {};
+  const method = String(req.method || 'GET').toUpperCase();
+  if (method !== 'POST') return { ok: true }; // 读接口放开：跨源读受 CORS 挡，媒体有 token
+
+  const sfs = String(headers['sec-fetch-site'] || '').toLowerCase();
+  if (sfs === 'cross-site') return { ok: false, status: 403, error: 'cross-site request denied' };
+
+  const origin = String(headers.origin || '');
+  if (origin) {
+    let oh = '';
+    try {
+      oh = new URL(origin).host.toLowerCase(); // host:port，与宿主 isTrustedApiRequest 同语义
+    } catch (_) {
+      return { ok: false, status: 403, error: 'bad origin' };
+    }
+    if (oh !== authority(headers.host)) return { ok: false, status: 403, error: 'cross-origin request denied' };
+  }
+  return { ok: true }; // 同源浏览器，或无 Origin 的本机 CLI/curl
+}
+
+/** 包裹路由 handler：未授权请求统一 403 人话 JSON，不进业务 handler */
+export function guarded(handler) {
+  return (req, res, ...rest) => {
+    const verdict = checkRequest(req);
+    if (!verdict.ok) {
+      if (res && !res.headersSent && typeof res.writeHead === 'function') {
+        try {
+          res.writeHead(verdict.status, { 'Content-Type': 'application/json; charset=utf-8', 'X-Content-Type-Options': 'nosniff' });
+          res.end(JSON.stringify({ error: verdict.error }));
+        } catch (_) {
+          /* 连接已死 */
+        }
+      }
+      return;
+    }
+    return handler(req, res, ...rest);
+  };
+}