mslxdff 0.1.56 → 0.1.57

package/bin/mslxdff.js

@@ -12,6 +12,7 @@ import { loadToken, refreshToken, setPort, getPort, loadGroupsJoined, saveGroups
 import { getPreferredModel } from "../src/auto.js";
 import { normalizeModel } from "../src/reasoning.js";
 import { syncToWorkbuddy, workbuddyModelsPath } from "../src/sync-workbuddy.js";
+import { syncToOpencode, opencodeConfigPath, toExternalAlias, toInternalId } from "../src/sync-opencode.js";
 import { startDaemon, stopDaemon, writePid, pidFile, logFile, readPid, readPidVersion, isPidAlive } from "../src/daemon.js";
 import { createAutoSelector } from "../src/auto.js";
 import { createPeersService } from "../src/peers.js";
@@ -313,14 +314,85 @@ if (args.includes("-model") || args.includes("-models")) {
   process.exit(0);
 }
 
-// -setto workbuddy [modelId]: set default model and sync to WorkBuddy models.json
+// -setto workbuddy|opencode [modelId]: sync to WorkBuddy / opencode
 if (args.includes("-setto") || args.includes("--setto")) {
   const idx = args.findIndex((x) => x === "-setto" || x === "--setto");
   const target = args[idx + 1];
-  if (target !== "workbuddy") {
-    console.error("usage: mslxdff -setto workbuddy [modelId]");
+  if (!["workbuddy", "opencode"].includes(target)) {
+    console.error("usage: mslxdff -setto workbuddy [modelId] | mslxdff -setto opencode [modelId]");
     process.exit(1);
   }
+  if (target === "opencode") {
+    const raw = args[idx + 2] && !String(args[idx + 2]).startsWith("-") ? String(args[idx + 2]).trim() : null;
+    let id;
+    let internal;
+    if (raw) {
+      if (raw === "auto" || !raw) {
+        console.error("modelId 不能为 auto 或空");
+        process.exit(1);
+      }
+      const norm = normalizeModel(raw);
+      if (!norm) {
+        console.error("modelId 不能为空");
+        process.exit(1);
+      }
+      savePreferredModel(norm);
+      console.log(`default model set to: ${norm} (daemon hot-reloads on next request)`);
+      internal = toInternalId(norm);
+      id = toExternalAlias(internal);
+    } else {
+      const pref = loadPreferredModel() || getPreferredModel();
+      if (!pref) {
+        console.error("no preferred model set; use: mslxdff -setto opencode <modelId>");
+        process.exit(1);
+      }
+      const norm = normalizeModel(pref);
+      if (!norm) {
+        console.error("modelId 不能为空");
+        process.exit(1);
+      }
+      internal = toInternalId(norm);
+      id = toExternalAlias(internal);
+    }
+    try {
+      const cacheFile = join(logDir(), "models.json");
+      const models = createModelsService({
+        baseUrl: process.env.UPSTREAM_BASE_URL || "https://opencode.ai",
+        headers: createUpstreamClient({}).headers,
+        refreshMs: 0,
+        cacheFile,
+      });
+      const fresh = await Promise.race([
+        models.get(),
+        new Promise((_, rej) => setTimeout(() => rej(new Error("refresh timeout")), 4000)),
+      ]);
+      if (fresh?.data?.length) {
+        const ids = fresh.data.map((m) => m.id);
+        if (!ids.includes(internal) && !ids.includes(id)) {
+          console.log(`warn: "${internal}" not in current free list (${ids.length} models), still syncing to opencode (alias ${id})`);
+        }
+      }
+    } catch {
+      // refresh failed, still proceed
+    }
+    try {
+      const { token } = await loadToken();
+      const persisted = getPort();
+      const envPort = Number(process.env.MSLXDFF_PORT);
+      const port = persisted !== null ? persisted : (Number.isInteger(envPort) && envPort > 0 ? envPort : 8989);
+      const file = opencodeConfigPath();
+      const r = await syncToOpencode({ id, token, port, file });
+      const aliasLabel = r.alias && r.alias !== r.id ? ` (alias ${r.alias} 对应内部 ${r.internal})` : (r.id !== r.internal ? ` (alias for "${r.internal}", 原名仍兼容)` : ` (原名兼容)`);
+      console.log(`synced to opencode: ${r.action} "${r.id}"${aliasLabel} @ ${file}`);
+      console.log(`  url: http://127.0.0.1:${port}/v1`);
+      if (r.id !== r.internal) console.log(`  alias: ${r.id} -> ${r.internal} (opencode 选 mslxdff/${r.id} 直达本地 ${r.internal})`);
+      else console.log(`  alias: ${r.internal} (原名直用，opencode 选 mslxdff/${r.id} 直达本地 ${r.internal})`);
+    } catch (err) {
+      console.error(`failed to sync to opencode: ${String(err?.message || err)}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
   const raw = args[idx + 2] && !String(args[idx + 2]).startsWith("-") ? String(args[idx + 2]).trim() : null;
   let id;
   if (raw) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.56",
+  "version": "0.1.57",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/routes/chat/index.js

@@ -1,6 +1,7 @@
 import { performance } from "node:perf_hooks";
 import { injectReasoningContent, normalizeModel } from "../../reasoning.js";
 import { isAutoModel } from "../../auto.js";
+import { toInternalId as aliasToInternal } from "../../sync-opencode.js";
 import { clientIp, json, readBody, parseHops, summarizePrompt, errMsg } from "../helpers.js";
 import { hedgeDelayMs, shouldHedge } from "../hedge.js";
 import { runHook } from "../../plugins.js";
@@ -39,9 +40,42 @@ export async function chatHandler({ req, res, upstream, auto, logs, peers, maxHo
   const workbuddyUid = (req.headers["x-mslxdff-workbuddy-uid"] || req.headers["x-workbuddy-uid"] || "").toString().trim();
   const lockModel = req.headers["x-mslxdff-model-lock"] || "";
   const rawModel = body.model || "";
-  const requested = normalizeModel(lockModel || rawModel || "");
+  const normalizedRequested = normalizeModel(lockModel || rawModel || "");
+  // alias 还原：mslxdff-deepseek -> deepseek（原名仍兼容，双向支持 mslxdff/mslxdff-deepseek 与裸 mslxdff-deepseek/裸 deepseek）
+  let requested = normalizedRequested;
+  let aliasInfo = null;
+  if (requested.startsWith("mslxdff-")) {
+    const internal = aliasToInternal(requested);
+    if (internal) {
+      aliasInfo = `${requested} -> ${internal}`;
+      requested = internal;
+    }
+  } else if (requested.includes("/")) {
+    const slashIdx = requested.indexOf("/");
+    const rawPart = requested.slice(slashIdx + 1);
+    const providerPart = requested.slice(0, slashIdx);
+    if (rawPart.startsWith("mslxdff-")) {
+      const internal = aliasToInternal(rawPart);
+      if (internal) {
+        aliasInfo = `${requested} -> ${providerPart}/${internal} (alias stripped)`;
+        requested = `${providerPart}/${internal}`;
+        if (providerPart === "mslxdff") {
+          requested = internal;
+          aliasInfo = `${rawModel} -> ${internal} (mslxdff alias stripped)`;
+        }
+      }
+    } else if (providerPart === "mslxdff") {
+      // mslxdff/deepseek 原名直用 -> deepseek（原名兼容，provider 前缀剥离）
+      aliasInfo = `${requested} -> ${rawPart} (mslxdff provider stripped, 原名兼容)`;
+      requested = rawPart;
+    }
+  }
   const useAuto = isAutoModel(requested);
   mark("parsed");
+  if (aliasInfo) {
+    // 供日志与 header 透传
+    try { res.setHeader("x-mslxdff-alias", aliasInfo); } catch {}
+  }
 
   let order;
   if (lockModel) {
@@ -70,6 +104,7 @@ export async function chatHandler({ req, res, upstream, auto, logs, peers, maxHo
     runHook(plugins, "request:completed", { reqId, requested, useAuto, hops, stream: Boolean(body.stream), durationMs: Date.now() - startedAt, ...info }).catch(() => {});
   };
   evt("request", { reqId, hops, ip: clientIp(req), stream: Boolean(body.stream), prompt: summarizePrompt(body), rawModel, requested, lockModel: lockModel || null });
+  if (aliasInfo) evt("alias", { reqId, alias: aliasInfo, rawModel, requested });
   if (Object.keys(shareKeys).length) evt("share-keys", { reqId, providers: Object.keys(shareKeys) });
   evt("ordered", { reqId, order, canFallback, canForwardPeers, useAuto, statuses: auto?.statuses?.() ?? null });
 

package/src/sync-opencode.js

@@ -0,0 +1,152 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync } from "node:fs";
+import { dirname, join } from "node:path";
+import os from "node:os";
+
+export function opencodeConfigPath() {
+  const env = process.env.OPENCODE_CONFIG || process.env.OPENCODE_CONFIG_PATH;
+  if (typeof env === "string" && env.trim()) return env.trim();
+  return join(os.homedir(), ".config", "opencode", "opencode.json");
+}
+
+export function toExternalAlias(id) {
+  const s = String(id || "").trim();
+  if (!s) return "";
+  return s.startsWith("mslxdff-") ? s : `mslxdff-${s}`;
+}
+
+export function toInternalId(aliasOrRaw) {
+  const s = String(aliasOrRaw || "").trim();
+  if (!s) return "";
+  return s.startsWith("mslxdff-") ? s.slice("mslxdff-".length) : s;
+}
+
+export function buildOpencodeProvider({ id, token, port }) {
+  const p = Number(port) || 8989;
+  const alias = toExternalAlias(id);
+  return {
+    name: "mslxdff",
+    npm: "@ai-sdk/openai-compatible",
+    options: {
+      apiKey: String(token || ""),
+      baseURL: `http://127.0.0.1:${p}/v1`,
+    },
+    models: {
+      [alias]: { name: alias },
+    },
+  };
+}
+
+export function isOpencodeLocalUrl(url) {
+  const u = String(url || "");
+  return u.includes("127.0.0.1") && u.includes("/v1");
+}
+
+export async function syncToOpencode({ id, token, port, file } = {}) {
+  const targetFile = file || opencodeConfigPath();
+  // id 可能是 alias 或原名，统一以 internal 去重、以 external 入库（原名兼容）
+  const normalizedRaw = String(id || "").trim();
+  if (!normalizedRaw) throw new Error("model id required");
+  const internal = toInternalId(normalizedRaw);
+  if (!internal) throw new Error("model id required");
+  const external = toExternalAlias(internal);
+  const cleanToken = String(token || "");
+  const p = Number(port) || 8989;
+
+  let data = null;
+  let corrupted = false;
+  let rawText = null;
+  try {
+    rawText = readFileSync(targetFile, "utf8");
+    const parsed = JSON.parse(rawText);
+    data = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch (err) {
+    if (rawText !== null) {
+      corrupted = true;
+      try {
+        mkdirSync(dirname(targetFile), { recursive: true });
+        writeFileSync(targetFile + ".bak", rawText ?? "", "utf8");
+      } catch {}
+      data = {};
+    } else {
+      data = {};
+    }
+  }
+
+  if (!data.provider || typeof data.provider !== "object" || Array.isArray(data.provider)) {
+    data.provider = {};
+  }
+
+  const oldProvider = data.provider.mslxdff && typeof data.provider.mslxdff === "object" && !Array.isArray(data.provider.mslxdff)
+    ? data.provider.mslxdff
+    : null;
+
+  let action;
+  let effectiveId = external;
+  if (oldProvider) {
+    const oldModels = oldProvider.models && typeof oldProvider.models === "object" && !Array.isArray(oldProvider.models)
+      ? oldProvider.models
+      : {};
+    // 去重：internal 或 external 任一已存在即视为已存在（原名兼容，以 internal 为基准）
+    const hasExternal = Object.prototype.hasOwnProperty.call(oldModels, external);
+    const hasInternal = Object.prototype.hasOwnProperty.call(oldModels, internal);
+    const exists = hasExternal || hasInternal;
+    const nextModels = { ...oldModels };
+    if (exists) {
+      if (hasExternal) {
+        nextModels[external] = { name: external, ...(oldModels[external] && typeof oldModels[external] === "object" ? oldModels[external] : {}), name: external };
+        effectiveId = external;
+      } else if (hasInternal) {
+        // 仅原名存在：保留原名不强制迁移为 alias，视为 updated（原名兼容）
+        nextModels[internal] = { name: internal, ...(oldModels[internal] && typeof oldModels[internal] === "object" ? oldModels[internal] : {}), name: internal };
+        effectiveId = internal;
+      }
+      action = "updated";
+    } else {
+      nextModels[external] = { name: external };
+      effectiveId = external;
+      action = "inserted";
+    }
+    // 合并 provider：保留 name/npm，覆盖 options.baseURL/apiKey，合并 models
+    const nextProvider = {
+      ...oldProvider,
+      name: oldProvider.name || "mslxdff",
+      npm: oldProvider.npm || "@ai-sdk/openai-compatible",
+      options: {
+        ...(oldProvider.options && typeof oldProvider.options === "object" ? oldProvider.options : {}),
+        baseURL: `http://127.0.0.1:${p}/v1`,
+        apiKey: cleanToken,
+      },
+      models: nextModels,
+    };
+    // 若插入的是 alias 但原名已存在，上面已处理为不新增；否则正常
+    data.provider.mslxdff = nextProvider;
+    // 若是新插入且 external 不等于 internal，且 internal 已存在时，需避免双键，上面已处理
+    // 若是新插入 external 且 internal 不存在，正常插入
+    if (!exists) {
+      data.provider.mslxdff.models = nextModels;
+    }
+  } else {
+    data.provider.mslxdff = buildOpencodeProvider({ id: external, token: cleanToken, port: p });
+    action = "inserted";
+  }
+
+  // 原子写
+  mkdirSync(dirname(targetFile), { recursive: true });
+  const tmp = `${targetFile}.tmp.${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+  writeFileSync(tmp, JSON.stringify(data, null, 2), "utf8");
+  try {
+    renameSync(tmp, targetFile);
+  } catch {
+    try {
+      writeFileSync(targetFile, readFileSync(tmp, "utf8"), "utf8");
+    } catch {}
+  }
+  try {
+    if (existsSync(tmp)) {
+      const { unlinkSync } = await import("node:fs");
+      unlinkSync(tmp);
+    }
+  } catch {}
+
+  return { action, file: targetFile, id: effectiveId, alias: external, internal, corrupted };
+}