mslxdff 0.1.104 → 0.1.105

package/package.json

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

package/src/chat-pipeline/serial-trial.js

@@ -9,6 +9,7 @@ import { handlePeerRelay } from "../routes/chat/peer-handler.js";
 import { handleBroadbandRelay } from "../routes/chat/broadband-handler.js";
 import { handleViaRoute } from "../routes/chat/via-route-handler.js";
 import { handleExhaustedLocal, handleExhaustedAll } from "../routes/chat/exhausted-handler.js";
+import { shouldUseGroupForModel } from "../state/schemas/use-group.js";
 
 /**
  * 串行 trial — 从 engine.js 抽出的第二段：via-route 单路径 → 串行 trial →
@@ -112,7 +113,8 @@ export async function runSerialTrial(ctx, deps = {}) {
       const isStream = Boolean(body.stream);
       const d = hedgeDelayMs();
       const hasPeers = Boolean(peers) && peers.ordered().length > 0;
-      const doHedge = shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, model }) && upRes.status === 200 && upRes.body;
+      const canUseGroup = shouldUseGroupForModel(model);
+      const doHedge = canUseGroup && shouldHedge({ isStream, canForwardPeers, hedgeDelayMs: d, hasPeers, model }) && upRes.status === 200 && upRes.body;
       if (doHedge) {
         const hr = await hedge({ upRes, model, body, order, idx, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, logError, mark, perf0, stages, startedAt, plugins, res, hedgeDelayMs: d });
         if (hr.handled) return { done: true };
@@ -128,12 +130,20 @@ export async function runSerialTrial(ctx, deps = {}) {
       }
     }
     if (canForwardPeers) {
-      const pr = await peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, stages, startedAt, plugins, res });
-      if (pr.handled) return { done: true };
+      if (!shouldUseGroupForModel(model)) {
+        evt("group-skip", { reqId, model, reason: "useGroup=off for opencode (peer)" });
+      } else {
+        const pr = await peerRelay({ model, body, lastErr, requested, useAuto, lockModel, auto, peers, handlerCtx, evt, logCall, mark, perf0, stages, startedAt, plugins, res });
+        if (pr.handled) return { done: true };
+      }
     }
     if (groups) {
-      const br = await broadbandRelay({ model, body, hops, lastErr, requested, useAuto, lockModel, auto, groups, token, bus, logs, handlerCtx, evt, mark, perf0, stages, res, startedAt, plugins });
-      if (br.handled) return { done: true };
+      if (!shouldUseGroupForModel(model)) {
+        evt("group-skip", { reqId, model, reason: "useGroup=off for opencode (broadband)" });
+      } else {
+        const br = await broadbandRelay({ model, body, hops, lastErr, requested, useAuto, lockModel, auto, groups, token, bus, logs, handlerCtx, evt, mark, perf0, stages, res, startedAt, plugins });
+        if (br.handled) return { done: true };
+      }
     }
     if (canFallback) { evt("fallback", { reqId, from: model, to: order[idx + 1] ?? null, reason: lastErr?.message || `upstream ${lastErr?.status ?? 502}` }); continue; }
     await exhaustedLocal({ res, body, lastErr, order, handlerCtx: { ...handlerCtx, model, reqId }, evt, logCall, mark, perf0, stages, done, requested, useAuto });

package/src/cli/commands/use-group.js

@@ -0,0 +1,56 @@
+import { loadUseGroup, saveUseGroup, getEffectiveUseGroup, getUseGroupEnv } from "../../state/schemas/use-group.js";
+import { argValue } from "../policy.js";
+
+function parseInput(v) {
+  if (v === undefined || v === null || v === "") return null;
+  const s = String(v).trim().toLowerCase();
+  if (["1", "true", "on", "yes", "enable", "enabled", "open"].includes(s)) return true;
+  if (["0", "false", "off", "no", "disable", "disabled", "close", "closed"].includes(s)) return false;
+  return null;
+}
+
+export async function handleUseGroup(args) {
+  const hasFlag = args.some((a) => ["-use-group", "--use-group", "-use_group", "--use_group", "-usegroup", "--usegroup"].includes(a));
+  if (!hasFlag) return false;
+
+  // 取值：支持 -use-group true / -use-group=true / --use-group=off
+  let raw = argValue(args, "-use-group", "--use-group", "-use_group", "--use_group", "-usegroup", "--usegroup");
+  // 兼容 -use-group=true 这种等号形态
+  if (raw === null || raw === undefined) {
+    const eq = args.find((a) => a.startsWith("-use-group=") || a.startsWith("--use-group=") || a.startsWith("-use_group=") || a.startsWith("--use_group="));
+    if (eq) raw = eq.split("=")[1];
+  }
+  // 如果 flag 后面紧跟的不是另一个 flag，则视为值；否则视为查询
+  if (raw !== null && raw !== undefined && String(raw).startsWith("-")) raw = null;
+
+  const envVal = getUseGroupEnv();
+  const effective = getEffectiveUseGroup();
+  const stored = loadUseGroup();
+
+  if (raw === null || raw === undefined || raw === "") {
+    // 查询模式
+    console.log(`use-group: ${effective ? "on" : "off"} (effective)`);
+    console.log(`  stored: ${stored ? "on" : "off"} (state.json useGroup)`);
+    if (envVal !== null) console.log(`  env MSLXDFF_USE_GROUP=${envVal ? "on" : "off"} (overrides stored)`);
+    console.log(`  default: on`);
+    console.log(`  usage: mslxdff -use-group on|off  (opencode 供应商本机失败时是否走组员网络，默认 on)`);
+    console.log(`  env:   MSLXDFF_USE_GROUP=0|1  (优先级高于 state)`);
+    process.exit(0);
+  }
+
+  const parsed = parseInput(raw);
+  if (parsed === null) {
+    console.error(`invalid value for -use-group: ${raw} (expected on/off/true/false/1/0)`);
+    process.exit(1);
+  }
+
+  if (envVal !== null) {
+    console.log(`note: env MSLXDFF_USE_GROUP=${envVal ? "on" : "off"} is set and overrides stored value; unset env to use stored value`);
+  }
+
+  saveUseGroup(parsed);
+  console.log(`use-group set to ${parsed ? "on" : "off"} (stored in state.json)`);
+  console.log(`  opencode 供应商：本机失败时 ${parsed ? "允许" : "不再"} 通过组员网络请求上游`);
+  if (!parsed) console.log(`  提示：opencode 请求将仅在本机重试，不再走 peer/broadband 组员中继`);
+  process.exit(0);
+}

package/src/cli/help.js

@@ -43,6 +43,7 @@ Usage:
   mslxdff -autostart status        查看自启状态
   mslxdff -chat ["prompt"]       chat REPL（mimo-v2.5-free 优先/big-pickle 兜底，自然语言转命令，模糊匹配由模型完成，历史持久化，超长自动压缩，仅拦 -uninstall，daemon 重启不影响）
   mslxdff -resetban [ip]           clear join-failure bans (all, or one ip)
+  mslxdff -use-group [on|off]     opencode 供应商本机失败时是否走组员网络（默认 on；off 则仅本机，MSLXDFF_USE_GROUP 环境变量可覆盖）
   mslxdff -help                    show this help
 
 Environment:
@@ -62,6 +63,7 @@ Environment:
   MSLXDFF_BAN_THRESHOLD   failed joins before an ip is banned (default 5)
   MSLXDFF_BAN_WINDOW_MS   ban duration after too many failures (default 48h)
   MSLXDFF_HEDGE_DELAY_MS  hedge peer race when local stream first chunk slow (default 1000, 0/off to disable)
+  MSLXDFF_USE_GROUP       opencode 组员中继开关（默认 on；0/off/false 关闭后 opencode 仅本机，不走 peer/broadband）
   MSLXDFF_AUTO_UPDATE   auto-update: hourly by default, 0/off/false to disable, 1/true or ms
   MSLXDFF_AUTO_UPDATE_MS  same as above, explicit ms (overrides AUTO_UPDATE)
 `);

package/src/cli/index.js

@@ -49,6 +49,8 @@ export async function run(args = process.argv.slice(2)) {
   if (await handleLeaveGroup(args)) return;
   if (await handleDelGroup(args)) return;
 
+  const { handleUseGroup } = await import("./commands/use-group.js");
+  if (await handleUseGroup(args)) return;
   const { handlePort, handleDaemonFlag, handleBareRun } = await import("./commands/daemon.js");
   if (await handlePort(args)) return;
   if (await handleDaemonFlag(args, VERSION)) return;

package/src/state/facade.js

@@ -57,3 +57,4 @@ export {
 export { loadPeers, savePeers, loadPeerErrors, savePeerErrors, loadPeerStats, savePeerStats } from "./schemas/peer.js";
 export { loadGroups, loadGroupsJoined, saveGroupsJoined, loadBans, saveBans, saveGroups } from "./schemas/group.js";
 export { loadTimezone, loadTimezoneState, saveTimezone, clearTimezone, getTimezoneEnv, DEFAULT_TZ, isValidTimezone } from "./schemas/timezone.js";
+export { loadUseGroup, saveUseGroup, getEffectiveUseGroup, shouldUseGroupForModel, isUseGroupEnabled, getUseGroupEnv } from "./schemas/use-group.js";

package/src/state/schemas/use-group.js

@@ -0,0 +1,56 @@
+import { defaultStateFile, readState, writeStateImmediate } from "../store.js";
+
+function parseBool(v) {
+  if (typeof v === "boolean") return v;
+  if (typeof v === "number") return v !== 0;
+  if (typeof v === "string") {
+    const s = v.trim().toLowerCase();
+    if (["0", "false", "off", "no", "disable", "disabled", "close", "closed"].includes(s)) return false;
+    if (["1", "true", "on", "yes", "enable", "enabled", "open"].includes(s)) return true;
+  }
+  return null;
+}
+
+export function loadUseGroup({ file = defaultStateFile() } = {}) {
+  const raw = readState(file).useGroup;
+  const parsed = parseBool(raw);
+  return parsed === null ? true : parsed; // 默认开
+}
+
+export function saveUseGroup(value, { file = defaultStateFile() } = {}) {
+  const b = Boolean(value);
+  writeStateImmediate(file, { useGroup: b });
+  return b;
+}
+
+export function getUseGroupEnv() {
+  const raw = process.env.MSLXDFF_USE_GROUP;
+  if (raw === undefined || raw === null || raw === "") return null;
+  return parseBool(raw);
+}
+
+export function getEffectiveUseGroup({ file = defaultStateFile() } = {}) {
+  const env = getUseGroupEnv();
+  if (env !== null) return env;
+  return loadUseGroup({ file });
+}
+
+// 仅对 opencode 供应商生效：opencode 的模型为裸 id 或 opencode/ 前缀
+export function shouldUseGroupForModel(model, { file = defaultStateFile() } = {}) {
+  const m = String(model || "").trim();
+  if (!m) return getEffectiveUseGroup({ file });
+  // 带前缀：判断是否为 opencode
+  if (m.includes("/")) {
+    const head = m.split("/")[0].trim().toLowerCase();
+    if (head === "opencode" || head === "oc") {
+      return getEffectiveUseGroup({ file });
+    }
+    return true; // 其他供应商不受此开关限制
+  }
+  // 裸 id 视为 opencode
+  return getEffectiveUseGroup({ file });
+}
+
+export function isUseGroupEnabled({ file } = {}) {
+  return getEffectiveUseGroup({ file });
+}