mslxdff 0.1.65 → 0.1.67

package/src/cli/commands/system.js

@@ -0,0 +1,236 @@
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defaultStateFile } from "../../state.js";
+import { loadToken, refreshToken } from "../../state.js";
+import { stopDaemon, pidFile, logFile } from "../../daemon.js";
+import { logDir, eventsFile, callsFile, errorsFile, recentEvents } from "../../logs.js";
+import { fmtEvent } from "../format.js";
+import { printHelp } from "../help.js";
+import { printStatus } from "../status.js";
+import { loadPlugins, resolvePluginDirs } from "../../plugins.js";
+
+export async function handleHelp(args, VERSION) {
+  if (!(args.includes("-help") || args.includes("--help") || args.includes("-h"))) return false;
+  printHelp(VERSION);
+  process.exit(0);
+}
+
+export async function handleUpdate(args, VERSION) {
+  if (!(args.includes("-update") || args.includes("--update"))) return false;
+  const { npmCmd, run } = await import("../util.js");
+  const { compareSemver } = await import("../policy.js");
+  const { resolvePort } = await import("../../server.js");
+  const { readPid } = await import("../../daemon.js");
+  const { startDaemon, stopDaemon } = await import("../../daemon.js");
+  const { waitForHealth } = await import("../policy.js");
+  console.log(`mslxdff v${VERSION} — checking for updates…`);
+  const info = await run(npmCmd(), ["view", "mslxdff", "dist-tags.latest", "--json"]);
+  if (info.err) {
+    console.error(`could not query npm: ${info.err.message || String(info.stderr || "").slice(0, 500)}`);
+    process.exit(1);
+  }
+  let latest = "";
+  try {
+    latest = JSON.parse(String(info.stdout || "").trim());
+    if (Array.isArray(latest)) latest = latest[latest.length - 1];
+    latest = String(latest || "").trim();
+  } catch {
+    const m = String(info.stdout || "").trim().match(/(\d+\.\d+\.\d+[^\s'"]*)/);
+    latest = m ? m[1] : "";
+  }
+  latest = String(latest || "").replace(/['"]/g, "").trim();
+  const version = VERSION;
+  console.log(`  installed: ${version}`);
+  console.log(`  latest:    ${latest || "unknown"}`);
+  if (!latest || version === latest || compareSemver(latest, version) <= 0) {
+    console.log("already up to date");
+    process.exit(0);
+  }
+  console.log(`updating to ${latest}…`);
+  const up = await run(npmCmd(), ["install", "-g", `mslxdff@${latest}`], { stdio: "inherit" });
+  if (up.err) {
+    console.error(`update failed: ${up.err.message}`);
+    process.exit(1);
+  }
+  console.log(`updated to ${latest}`);
+  const daemon = readPid();
+  if (daemon) {
+    console.log("restarting daemon on the new version…");
+    stopDaemon();
+    startDaemon([]);
+    await waitForHealth(resolvePort(), 4000);
+    console.log(`restarted (pid ${readPid()})`);
+  }
+  process.exit(0);
+}
+
+export async function handleRefreshToken(args) {
+  if (!(args.includes("-refresh-token") || args.includes("--refresh-token"))) return false;
+  const token = await refreshToken();
+  console.log(token);
+  process.exit(0);
+}
+
+export async function handleShowToken(args) {
+  if (!(args.includes("-showtoken") || args.includes("--showtoken"))) return false;
+  const { token } = await loadToken();
+  console.log(token);
+  process.exit(0);
+}
+
+export async function handleUninstall(args) {
+  if (!(args.includes("-uninstall") || args.includes("--uninstall"))) return false;
+  const { stopped, pid } = stopDaemon();
+  if (stopped) console.log(`mslxdff daemon stopped (pid ${pid})`);
+  else console.log("mslxdff daemon not running");
+  const stateFile = defaultStateFile();
+  const dir = dirname(stateFile);
+  const removed = [];
+  for (const f of [
+    stateFile,
+    pidFile(),
+    logFile(),
+    join(dir, "calls.log"),
+    join(dir, "errors.log"),
+    join(dir, "events.log"),
+  ]) {
+    try {
+      rmSync(f, { force: true });
+      removed.push(f);
+    } catch {}
+  }
+  if (removed.length) console.log(`removed ${removed.length} file(s):\n  ${removed.join("\n  ")}`);
+  else console.log("no state/log files to remove");
+  console.log("\npackage still installed — finish with:");
+  console.log("  npm uninstall -g mslxdff");
+  process.exit(0);
+}
+
+export async function handleLog(args) {
+  if (!(args.includes("-log") || args.includes("--log") || args.includes("-logs") || args.includes("--logs"))) return false;
+  const idx = args.findIndex((x) => x === "-log" || x === "--log" || x === "-logs" || x === "--logs");
+  const raw = args[idx + 1];
+  const n = Number(raw);
+  const count = Number.isInteger(n) && n > 0 ? n : 10;
+  const file = eventsFile();
+  const dir = logDir();
+  console.log(`log dir: ${dir}`);
+  console.log(`events:  ${file}`);
+  const evts = recentEvents(count);
+  if (!evts.length) {
+    console.log(`(no events yet — file empty or not found)`);
+  } else {
+    console.log(`--- last ${evts.length} event(s) ---`);
+    for (const e of evts) console.log(fmtEvent(e));
+  }
+  if (count <= 10) {
+    console.log(`\nhint: mslxdff -log 100  |  calls: ${callsFile()}  errors: ${errorsFile()}  daemon: ${logFile()}`);
+  }
+  process.exit(0);
+}
+
+export async function handlePlugins(args) {
+  if (!(args.includes("-plugins") || args.includes("--plugins"))) return false;
+  const pkgRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+  const dirs = resolvePluginDirs({ pkgRoot: dirname(pkgRoot) });
+  // Actually pkgRoot is src/cli -> need to go to root: bin/mslxdff.js used dirname(dirname(...)). For src/cli/commands/system.js, need 3 levels.
+  // Simpler: compute from import.meta.url
+  const root = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..");
+  const dirs2 = resolvePluginDirs({ pkgRoot: root });
+  const labels = ["official (bundled)", "user"];
+  if (dirs2.length === 1) labels[0] = "dir";
+  console.log(`plugin dirs:`);
+  dirs2.forEach((d, i) => console.log(`  [${labels[i] || `dir${i + 1}`}] ${d}${existsSync(d) ? "" : "  (not created yet)"}`));
+  const { plugins, errors } = await loadPlugins({ dirs: dirs2 });
+  if (!plugins.length && !errors.length) {
+    console.log("(no plugins — drop *.mjs files into a dir above, see docs/plugins.md)");
+  }
+  for (const p of plugins) {
+    const hooks = Object.keys(p.hooks || {});
+    const src = p.file.startsWith(root) ? "official" : "user";
+    console.log(`  ${p.name}${p.version ? `@${p.version}` : ""}  [${hooks.join(", ") || "no hooks"}]  (${src})`);
+    if (p.description) console.log(`    ${p.description}`);
+  }
+  for (const e of errors) console.log(`  load error: ${e.file} — ${e.error}`);
+  process.exit(0);
+}
+
+export async function handleChat(args) {
+  if (!(args.includes("-chat") || args.includes("--chat"))) return false;
+  const idx = args.findIndex((x) => x === "-chat" || x === "--chat");
+  const rest = args.slice(idx + 1);
+  const singleShot = rest.length ? rest.join(" ").trim() : null;
+  const { startChat } = await import("../../chat/index.js");
+  await startChat({ singleShot: singleShot || undefined });
+  process.exit(0);
+}
+
+export async function handleStatus(args, VERSION) {
+  if (!(args.includes("-status") || args.includes("--status") || args.includes("-s"))) return false;
+  await printStatus(VERSION);
+  process.exit(0);
+}
+
+export async function handleFree(args) {
+  if (!(args.includes("-free") || args.includes("--free") || args.includes("-free-check") || args.includes("--free-check") || args.includes("-free-watch") || args.includes("--free-watch"))) return false;
+  const isWatch = args.includes("-free-watch") || args.includes("--free-watch");
+  const { fetchV2exFree } = await import("../../free-watcher.js");
+  const show = async () => {
+    const hits = await fetchV2exFree({ timeoutMs: 6000 });
+    const ts = new Date().toISOString().replace("T", " ").slice(0, 19);
+    console.log(`[V2EX] free check @ ${ts} — ${hits.length} hit(s)`);
+    if (!hits.length) {
+      console.log("(暂无命中 — 关键词：白嫖|限免|免费额度|注册送|羊毛，来源：/api/topics/latest.json + hot.json)");
+    } else {
+      for (const h of hits) console.log(`  ${h.title} | ${h.url} | ${h.node} ${h.replies}回复`);
+    }
+  };
+  if (!isWatch) {
+    try { await show(); } catch (err) { console.error(`V2EX 拉取失败: ${err?.message || err}`); process.exit(1); }
+    process.exit(0);
+  }
+  console.log("V2EX 白嫖雷达 watch 模式 — 每 5 分钟拉一次 Ctrl+C 退出");
+  const run = async () => {
+    try { await show(); } catch (err) { console.error(`[${new Date().toISOString().slice(11,19)}] 拉取失败: ${err?.message || err}`); }
+    console.log("---");
+  };
+  await run();
+  const timer = setInterval(run, 5 * 60 * 1000);
+  timer.unref?.();
+  await new Promise(() => {});
+}
+
+export async function handleAutostart(args) {
+  if (!(args.includes("-enable-autostart") || args.includes("--enable-autostart") || args.includes("-disable-autostart") || args.includes("--disable-autostart") || args.includes("-autostart") || args.includes("--autostart"))) return false;
+  const { enableAutostart, disableAutostart, getAutostartStatus, autostartHelp } = await import("../../autostart.js");
+  if (args.includes("-enable-autostart") || args.includes("--enable-autostart")) {
+    const r = await enableAutostart();
+    if (r.ok) {
+      console.log(`autostart 已启用 · ${r.method || autostartHelp()}`);
+      console.log(`验证: mslxdff -autostart status`);
+    } else {
+      console.error(`启用自启失败: ${r.error || "unknown"}`);
+      console.error(`提示: Windows 需允许任务计划，Linux 需 systemd --user`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+  if (args.includes("-disable-autostart") || args.includes("--disable-autostart")) {
+    const r = await disableAutostart();
+    if (r.ok) console.log(`autostart 已禁用`);
+    else { console.error(`禁用失败: ${r.error}`); process.exit(1); }
+    process.exit(0);
+  }
+  const idx = args.findIndex((x) => x === "-autostart" || x === "--autostart");
+  const sub = args[idx + 1];
+  if (!sub || sub === "status" || sub === "list") {
+    const s = await getAutostartStatus();
+    console.log(`autostart: ${s.enabled ? "已启用" : "未启用"} · ${s.detail || autostartHelp()}`);
+    if (s.taskToRun) console.log(`  task: ${s.taskToRun}`);
+    if (s.unit) console.log(`  unit: ${s.unit}`);
+    process.exit(0);
+  }
+  console.error("usage: mslxdff -enable-autostart | mslxdff -disable-autostart | mslxdff -autostart status");
+  process.exit(1);
+}

package/src/cli/commands/workbuddy.js

@@ -0,0 +1,91 @@
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export async function handleWorkbuddy(args) {
+  if (!(args.includes("-workbuddy") || args.includes("--workbuddy") || args.includes("-wb"))) return false;
+  const idx = args.findIndex((x) => x === "-workbuddy" || x === "--workbuddy" || x === "-wb");
+  const sub = args[idx + 1];
+  if (!sub || sub === "checkin" || sub === "daily-checkin" || sub === "check-in") {
+    const { spawn } = await import("node:child_process");
+    const script = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "workbuddy-checkin.js");
+    // for src/cli/commands/workbuddy.js -> ../../../workbuddy-checkin.js is root/workbuddy-checkin.js
+    const child = spawn(process.execPath, [script, ...args.slice(idx + 2)], { stdio: "inherit" });
+    child.on("close", (code) => process.exit(code ?? 0));
+    child.on("error", (err) => { console.error(`workbuddy checkin failed: ${err.message}`); process.exit(1); });
+    await new Promise(() => {});
+  } else if (sub === "balance" || sub === "balances" || sub === "credit" || sub === "credits") {
+    const asJson = args.includes("--json") || args.includes("-json");
+    const { loadProviderConfigs } = await import("../../state.js");
+    const { fetchBalance } = await import("../../providers/workbuddy-balance.js");
+    const cfg = loadProviderConfigs().workbuddy || {};
+    const auths = Array.isArray(cfg.auths) ? cfg.auths : [];
+    const keys = Array.isArray(cfg.keys) ? cfg.keys : [];
+    let items = auths.map((a,i)=> ({ uid:a.uid, domain:a.domain, key: keys[i]||"" , auth:a }));
+    if (!items.length) {
+      try {
+        const { readdirSync, readFileSync, existsSync } = await import("node:fs");
+        const { join } = await import("node:path");
+        const dir = process.env.WORKBUDDY_AUTH_DIR || join(process.cwd(), "auths");
+        if (existsSync(dir)) {
+          for (const f of readdirSync(dir).filter(x=>x.startsWith("workbuddy-")&&x.endsWith(".json"))) {
+            try { const j=JSON.parse(readFileSync(join(dir,f),"utf8")); if(j?.account?.uid) items.push({uid:j.account.uid, domain:j.auth.domain||"www.codebuddy.cn", key:j.auth.accessToken, auth:{uid:j.account.uid, domain:j.auth.domain||"www.codebuddy.cn", enterpriseId:j.account.enterpriseId||""}}); } catch {}
+          }
+        }
+      } catch {}
+    }
+    if (!items.length) { console.log("no workbuddy accounts — run node workbuddy-token-auto.js"); process.exit(0); }
+    const results=[];
+    for (const it of items) {
+      const b = await fetchBalance({ uid: it.uid, key: it.key, auth: it.auth }).catch(()=>null);
+      results.push({ uid: it.uid, domain: it.domain, balance: b });
+    }
+    if (asJson) { console.log(JSON.stringify({ results }, null, 2)); process.exit(0); }
+    console.log(`workbuddy balances (${results.length}):`);
+    for (const r of results) {
+      const b=r.balance;
+      if (!b) console.log(`  ${r.uid}  (balance unavailable)  domain=${r.domain}`);
+      else console.log(`  ${r.uid}  total=${b.totalStr||b.total}  dailyPacks=${b.dailyPacks}  active=${b.activeCount}  nextExpire=${b.nextExpire||"-"}  domain=${r.domain}`);
+    }
+    process.exit(0);
+  } else if (sub === "list" || sub === "ls" || sub === "status") {
+    const { loadProviderConfigs } = await import("../../state.js");
+    const cfg = loadProviderConfigs().workbuddy || {};
+    const auths = Array.isArray(cfg.auths) ? cfg.auths : [];
+    const keys = Array.isArray(cfg.keys) ? cfg.keys : [];
+    if (!auths.length) { console.log("no workbuddy accounts in state — check auths/workbuddy-*.json"); process.exit(0); }
+    console.log(`workbuddy accounts (${auths.length}):`);
+    auths.forEach((a,i)=> {
+      const k=(keys[i]||"").slice(0,4);
+      console.log(`  [${i+1}] uid=${a.uid} domain=${a.domain||"www.codebuddy.cn"} enterprise=${a.enterpriseId||"-"} key=${k?k+"…":"(none)"} refresh=${a.refreshToken?"yes":"no"}`);
+    });
+    process.exit(0);
+  } else if (sub === "remove" || sub === "rm" || sub === "del" || sub === "delete") {
+    const target = args[idx+2];
+    if (!target) { console.error("usage: mslxdff -workbuddy remove <uid> [--keep-file]"); process.exit(1); }
+    const keep = args.includes("--keep-file");
+    const { loadProviderConfigs, saveProviderConfig } = await import("../../state.js");
+    const cfg = loadProviderConfigs().workbuddy || {};
+    let auths = Array.isArray(cfg.auths)? [...cfg.auths]:[];
+    let keys = Array.isArray(cfg.keys)? [...cfg.keys]:[];
+    let rmIdx = auths.findIndex(a=> a.uid===target || a.uid.startsWith(target));
+    if (rmIdx<0) { console.error(`uid not found: ${target}`); process.exit(1); }
+    const uid = auths[rmIdx].uid;
+    auths.splice(rmIdx,1); keys.splice(rmIdx,1);
+    saveProviderConfig("workbuddy", { baseUrl: cfg.baseUrl||"https://copilot.tencent.com", keys, auths });
+    if (!keep) {
+      try {
+        const { existsSync, unlinkSync } = await import("node:fs");
+        const { join } = await import("node:path");
+        const dir = process.env.WORKBUDDY_AUTH_DIR || join(process.cwd(), "auths");
+        const fp = join(dir, `workbuddy-${uid}.json`);
+        if (existsSync(fp)) { unlinkSync(fp); console.log(`removed file ${fp}`); }
+      } catch {}
+    }
+    try { const { getBalanceCache } = await import("../../providers/workbuddy-balance.js"); getBalanceCache().delete(uid); } catch {}
+    console.log(`removed workbuddy ${uid} (now ${auths.length} account(s))`);
+    process.exit(0);
+  } else {
+    console.error("usage: mslxdff -workbuddy checkin | balance [--json] | list | remove <uid>");
+    process.exit(1);
+  }
+}

package/src/cli/format.js

@@ -0,0 +1,119 @@
+import { fmtShanghai, fmtShanghaiHMS } from "../time.js";
+
+export function fmtStatus(id, statuses) {
+  const e = statuses[id];
+  if (typeof e === "number") return `error ${fmtTs(e)}`;
+  if (!e?.status || e.status === "normal") return "";
+  const when = e.at ? ` ${fmtTs(e.at)}` : "";
+  const code = e.code ? ` HTTP ${e.code}` : "";
+  return `${e.status}${when}${code}`;
+}
+
+export function fmtDur(ms) {
+  if (!Number.isFinite(ms)) return "?";
+  return ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+
+export function fmtUptime(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "?";
+  const s = Math.floor(ms / 1000);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const h = Math.floor(m / 60);
+  const d = Math.floor(h / 24);
+  if (d) return `${d}d${h % 24}h`;
+  if (h) return `${h}h${m % 60}m`;
+  return `${m}m${s % 60}s`;
+}
+
+export function fmtEvent(e) {
+  const t = e?.ts ? fmtShanghaiHMS(e.ts) : "--:--:--";
+  const head = `[${t}]`;
+  const m = (x) => x || "-";
+  const fallbackTag = e.fallback?.fallback ? ` fallback=${e.fallback.requested_model || e.requested}->${e.fallback.actual_model || e.actual}(${e.fallback.reason || e.reason})` : "";
+  switch (e?.type) {
+    case "request":
+      return `${head} request       client-> ${m(e.requested || e.model)}${e.auto ? " (auto)" : ""} raw=${m(e.rawModel)} lock=${m(e.lockModel)} hops=${e.hops} from ${e.ip || "?"}${e.stream ? " stream" : ""}${e.prompt ? ` content="${e.prompt}"` : ""} reqId=${e.reqId || ""}`;
+    case "client-request":
+      return `${head} client req    客户端请求 model=${m(e.requested)} raw=${m(e.rawModel)} lock=${m(e.lockModel)} ip=${e.ip || "?"}${e.stream ? " stream" : ""}`;
+    case "ordered":
+      return `${head} ordered       尝试顺序 [${(e.order||[]).join(" -> ")}] canFallback=${e.canFallback} useAuto=${e.useAuto}`;
+    case "model-try":
+      return `${head} model-try     尝试本地 model=${m(e.model)} idx=${e.idx} reqId=${e.reqId || ""}`;
+    case "upstream-try":
+      return `${head} upstream try  上游请求 model=${m(e.model)} attempt=${e.attempt || 1}`;
+    case "upstream-done":
+      return `${head} upstream ok   ${m(e.model)} HTTP ${e.status}${e.timing ? ` total=${e.timing.totalMs}ms` : ""}`;
+    case "upstream-error":
+      return `${head} upstream err  ${m(e.model)} ${e.status ? `HTTP ${e.status}` : "network"}: ${m(e.message)}`;
+    case "upstream-preheat":
+      if (e.skipped) return `${head} preheat       跳过 (MSLXDFF_PREHEAT disabled)`;
+      return `${head} preheat       预热 opencode models ${e.ok ? "ok" : "fail"} ${e.status ? `HTTP ${e.status}` : e.error || ""} ${e.ms ? `${e.ms}ms` : ""}`;
+    case "peer-race-start":
+      return `${head} peer race     开始并发给组员 model=${m(e.model)} peers=${e.peers}`;
+    case "peer-health":
+      return `${head} peer check    ${e.peer} -> ${e.count ? e.healthy.join(", ") : "no healthy models"}${e.strict ? " (strict)" : ""}`;
+    case "peer-request":
+      return `${head} peer req      并发发出 peer=${e.peer} model=${m(e.model)} hops=${e.hops}`;
+    case "peer-forward":
+      return `${head} peer resp     收到响应 peer=${e.peer} model=${m(e.model)} ${e.ok ? "ok" : "fail"} ${e.latencyMs ? `${e.latencyMs}ms` : ""} hops=${e.hops}${e.retry ? " (retry)" : ""}`;
+    case "peer-error":
+      return `${head} peer err      ${e.peer} ${e.status ? `HTTP ${e.status}` : "network"}: ${m(e.message)} model=${m(e.model)}`;
+    case "peer-race-win":
+      return `${head} peer win      选中 peer=${e.winPeer} model=${m(e.winTarget)} latency=${e.latencyMs}ms`;
+    case "peer-race-lose":
+      return `${head} peer lose     组员全部失败 model=${m(e.model)}`;
+    case "fallback":
+      return `${head} fallback      ${m(e.from)} -> ${m(e.to)} reason=${m(e.reason)}`;
+    case "fallback-notice":
+      return `${head} fallback!     客户端请求 ${m(e.requested)} 实际返回 ${m(e.actual)} 原因=${m(e.reason)} via=${m(e.via)} notice=${m(e.notice)}`;
+    case "relay-try":
+      return `${head} relay try     给宽带中继请求 target=${e.target} model=${m(e.model)} via=${e.via}`;
+    case "relay-fail":
+      return `${head} relay fail    ${e.target} ${e.status ? `HTTP ${e.status}` : ""} ${m(e.message)}`;
+    case "relay-ip-change":
+      return `${head} relay ip      ${e.member || e.id || "?"} ${e.oldIp || "?"} -> ${e.newIp || e.publicIp || "?"} via leader`;
+    case "relay-forward":
+      return `${head} relay fwd     ${e.target || e.peer || "?"} via leader model=${m(e.model)} hops=${e.hops || 0}`;
+    case "relay-heartbeat":
+      return `${head} relay hb      ${e.member || "?"} ip=${e.ip || "?"} lastSeen=${e.lastSeen ? fmtShanghaiHMS(e.lastSeen) : "?"}`;
+    case "client-abort":
+      return `${head} client abort  ${m(e.model)} total=${fmtDur(e.totalMs)}`;
+    case "result":
+      return `${head} result        返回客户端 status=${e.status} model=${m(e.model)} via=${e.via} 响应耗时 ${fmtDur(e.durationMs)}${fallbackTag}`;
+    case "client-response":
+      return `${head} client res    返回客户端 客户端请求 ${m(e.requested)} 实际返回 ${m(e.actual)} via=${m(e.via)}${e.fallback?.fallback ? ` fallback=${e.fallback.requested_model}->${e.fallback.actual_model}(${e.fallback.reason})` : " 无fallback"} status=${e.status}`;
+    case "auto-update-enabled":
+      return `${head} auto-update   enabled every ${Math.round((e.intervalMs||0)/60000)}m current=${e.current}`;
+    case "auto-update-disabled":
+      return `${head} auto-update   disabled current=${e.current}`;
+    case "auto-update-check":
+      return `${head} auto-update   checking current=${e.current}`;
+    case "auto-update-query":
+      return `${head} auto-update   querying npm current=${e.current}`;
+    case "auto-update-queried":
+      return `${head} auto-update   queried current=${e.current} latest=${e.latest} raw=${(e.stdout||"").slice(0,80)}`;
+    case "auto-update-noop":
+      return `${head} auto-update   noop current=${e.current} latest=${e.latest}${e.reason?` reason=${e.reason}`:""}`;
+    case "auto-update-found":
+      return `${head} auto-update   NEW v${e.current} -> v${e.latest} 发现新版本`;
+    case "auto-update-installing":
+      return `${head} auto-update   installing v${e.latest}...`;
+    case "auto-update-installed":
+      return `${head} auto-update   installed v${e.latest}`;
+    case "auto-update-restarting":
+      return `${head} auto-update   restarting daemon to v${e.latest}...`;
+    case "auto-update-restarted":
+      return `${head} auto-update   restarted pid=${e.newPid} v${e.current} -> v${e.latest} 升级完成`;
+    case "auto-update-failed":
+    case "auto-update-query-failed":
+    case "auto-update-install-failed":
+      return `${head} auto-update   failed ${e.type} error=${e.error||""}`;
+    default:
+      return `${head} ${e?.type || "?"} ${JSON.stringify(e || {})}`;
+  }
+}
+
+export function fmtTs(iso) {
+  return fmtShanghai(iso);
+}

package/src/cli/group-helpers.js

@@ -0,0 +1,69 @@
+import { loadToken, loadGroupsJoined, saveGroupsJoined } from "../state.js";
+import { refreshGroupMembers, syncPeersFromMembers } from "../groups.js";
+import { errMsg } from "./util.js";
+
+const HEALTH_TIMEOUT_MS = 4000;
+
+export function groupIs(action, argv) {
+  const idx = argv.indexOf("-group");
+  if (idx < 0) return null;
+  return argv[idx + 1] === action ? argv[idx + 2] : null;
+}
+
+export function markJoined(entry) {
+  const { name } = entry;
+  if (!entry.kind) entry.kind = "static";
+  const list = loadGroupsJoined().filter((g) => g.name !== name);
+  saveGroupsJoined([...list, entry]);
+}
+
+export async function probeHealth({ id, url, kind, lastSeen, publicIp } = {}) {
+  if (!url) return { id, url, fail: "no url", rank: 3 };
+  const isBb = kind === "broadband" || String(url).startsWith("relay://");
+  if (isBb) {
+    const staleMs = Number(process.env.MSLXDFF_BROADBAND_STALE_MS) > 0 ? Number(process.env.MSLXDFF_BROADBAND_STALE_MS) : 90_000;
+    const stale = typeof lastSeen === "number" ? Date.now() - lastSeen > staleMs : true;
+    return { id, url, kind: "broadband", lastSeen, publicIp, stale, rank: stale ? 2 : 0 };
+  }
+  const base = String(url).replace(/\/+$/, "");
+  const startedAt = Date.now();
+  try {
+    const res = await fetch(`${base}/health`, { signal: AbortSignal.timeout(HEALTH_TIMEOUT_MS) });
+    if (!res.ok) return { id, url: base, fail: `HTTP ${res.status}`, rank: 2 };
+    return { id, url: base, ms: Date.now() - startedAt, rank: 0 };
+  } catch (err) {
+    return { id, url: base, fail: errMsg(err), rank: 2 };
+  }
+}
+
+export async function syncAllJoinedGroups({ peers, groups }) {
+  const joined = loadGroupsJoined();
+  const myToken = (await loadToken()).token;
+  const results = [];
+  for (const g of joined) {
+    try {
+      if (g.leaderUrl) {
+        const members = await refreshGroupMembers(g.name, {
+          leaderUrl: g.leaderUrl,
+          memberName: g.memberName,
+          url: g.myUrl,
+          token: myToken,
+          kind: g.kind,
+        });
+        results.push({
+          name: g.name,
+          ...syncPeersFromMembers({ peers, members, myUrl: g.myUrl, group: g.name }),
+        });
+      } else {
+        const members = groups.list()[g.name]?.members ?? {};
+        results.push({
+          name: g.name,
+          ...syncPeersFromMembers({ peers, members, myUrl: g.myUrl, group: g.name, skipIds: ["leader"] }),
+        });
+      }
+    } catch (err) {
+      results.push({ name: g.name, error: errMsg(err) });
+    }
+  }
+  return results;
+}

package/src/cli/help.js

@@ -0,0 +1,66 @@
+export function printHelp(VERSION) {
+  console.log(`mslxdff v${VERSION} — OpenCode Free OpenAI-compatible proxy
+
+Usage:
+  mslxdff                          start as a background daemon and exit (status + help if one is already running)
+  mslxdff -d                       start as a background daemon
+  mslxdff -status                  show current status (daemon/health/port/config, upstream providers, models + metrics/体检表, autostart/plugins, groups/peers, recent calls with ttfb/tps, last error)
+  mslxdff -log [N]                 show last N events (default 10, e.g. -log 100)
+  mslxdff -models                interactive picker: ↑/↓ select a model, Enter sets it as the default (non-TTY: plain list)
+  mslxdff -model list            list the free models this proxy serves (cached)
+  mslxdff -model set <id>        set the default (preferred) model without the interactive picker
+  mslxdff -model status            show per-model health status (normal/limit/error)
+  mslxdff -model refresh           force-refresh the model cache from the upstream
+  mslxdff -debug                   live-follow the daemon event stream (requests, errors, peer forwards)
+  mslxdff -stop                    stop the running daemon
+  mslxdff -restart                 restart the daemon
+  mslxdff -uninstall               stop the daemon and delete all state/log files
+  mslxdff -port N                  persist the listen port (restarts the daemon on it if running)
+  mslxdff -update                  update mslxdff to the latest published version
+  mslxdff -showtoken               print the current auth token
+  mslxdff -refresh-token           rotate the auth token (prints the new one)
+  mslxdff -setto workbuddy [modelId]  set default model and sync to WorkBuddy models.json (insert or update 127.0.0.1/v1 entry)
+  mslxdff -provider add <id> <baseUrl> <key> [allowedModel...]  add a generic OpenAI-compatible provider (myapi/gpt-4, baseUrl https://api.example.com/v1; extra models = allowlist)
+  mslxdff -provider add workbuddy https://copilot.tencent.com <key> [allow...]  add WorkBuddy专用供应商（workbuddy/hy3 前缀路由，auths 与 keys 一一对应）
+  mslxdff -provider <id> [key...|add|remove|list|clear|share|set-url]  configure provider API keys/URL (multiple keys = rotating, set-url for generic)
+  mslxdff -provider <id> allowlist [list|set|add|remove|clear]  manage allowed models (empty=allow all, non-empty=only listed) 
+  mslxdff -workbuddy checkin        daily 100 credits（双域幂等，已签 code 10001 视为成功）
+  mslxdff -providers list          list all configured upstream providers (opencode, openrouter, generic, workbuddy)
+  mslxdff -creategroup <name>      create a group on this node (the group name is the password)
+  mslxdff -addtogroup <leader-host> <name> [--broadband]  join a group via its leader host (default port 8989) — broadband: 宽带动态IP成员（经Leader中继，无需公网入站，默认127.0.0.1）
+  mslxdff -group sync              pull the freshest member list for all joined groups
+  mslxdff -group leave <name>      leave a group (removes its members from this node)
+  mslxdff -group list              list groups on this node (numbered members)
+  mslxdff -group remove <seq>      leader only: kick a member by its list sequence number
+  mslxdff -leavegroup              leave every joined group as a member (leaders: use -delgroup)
+  mslxdff -delgroup <name>         disband a group this node leads (deletes it and its members)
+  mslxdff -free                    V2EX 白嫖雷达（仅 V2EX 单源：latest+hot 按 白嫖|限免|免费额度|注册送|羊毛 过滤）
+  mslxdff -free-watch              V2EX 白嫖雷达 watch 模式（每 5 分钟轮询）
+  mslxdff -enable-autostart        开机自启：注册 Windows 任务计划 / Linux systemd user（重启后自动拉起）
+  mslxdff -disable-autostart       关闭开机自启
+  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 -help                    show this help
+
+Environment:
+  MSLXDFF_PORT          listen port (default 8989; use mslxdff -port N to persist)
+  MSLXDFF_STATE_FILE      token/port state file
+  MSLXDFF_DAEMON_DIR      daemon pid/log/models dir
+  UPSTREAM_BASE_URL       upstream base (default https://opencode.ai)
+  UPSTREAM_AUTH_TOKEN     upstream bearer value (default "public")
+  MSLXDFF_OPENROUTER_KEY  openrouter provider API keys(s) (single env value; multiple use "mslxdff -provider openrouter k1 k2 ..." to persist)
+  UPSTREAM_CONNECT_TIMEOUT_MS  upstream connect timeout (default 30000)
+  MODELS_REFRESH_MS       model-list background refresh interval (default 7200000)
+  MSLXDFF_MODEL_COOLDOWN_MS  fallback cooldown after a model error (default 60000)
+  MSLXDFF_PEER_COOLDOWN_MS   peer failover cooldown (default 30000)
+  MSLXDFF_PEER_HEAT_MS       how long a peer success stays hot for fast reuse (default 300000)
+  MSLXDFF_GROUP_SYNC_MS   group membership sync interval (default 60000)
+  MSLXDFF_MAX_HOPS           max peer-forwarding depth (default 3)
+  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_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

@@ -0,0 +1,59 @@
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const VERSION = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf8")).version;
+
+// deep CLI entry — single inlet: run(args) — hides all command branching inside
+export async function run(args = process.argv.slice(2)) {
+  const { handleHelp, handleUpdate, handleRefreshToken, handleShowToken, handleUninstall, handleLog, handlePlugins, handleChat, handleStatus, handleFree, handleAutostart } = await import("./commands/system.js");
+  if (await handleHelp(args, VERSION)) return;
+  if (await handleUpdate(args, VERSION)) return;
+  if (await handleRefreshToken(args)) return;
+  if (await handleShowToken(args)) return;
+
+  const { handleStop, handleRestart } = await import("./commands/daemon.js");
+  if (await handleStop(args)) return;
+  if (await handleRestart(args, VERSION)) return;
+  if (await handleUninstall(args)) return;
+  if (await handleLog(args)) return;
+  if (await handlePlugins(args)) return;
+  if (await handleChat(args)) return;
+  if (await handleStatus(args, VERSION)) return;
+
+  const { handleModel } = await import("./commands/model.js");
+  if (await handleModel(args)) return;
+  const { handleSetto } = await import("./commands/sync.js");
+  if (await handleSetto(args)) return;
+  const { handleWorkbuddy } = await import("./commands/workbuddy.js");
+  if (await handleWorkbuddy(args)) return;
+
+  if (await handleAutostart(args)) return;
+  if (await handleFree(args)) return;
+
+  const { handleProviders, handleProvider } = await import("./commands/provider.js");
+  if (await handleProviders(args)) return;
+  if (await handleProvider(args)) return;
+
+  const { handleDebug } = await import("./commands/daemon.js");
+  await handleDebug(args);
+
+  const { handleGroupCreate, handleGroupCommand, handleAddToGroup, handleResetBan, handleLeaveGroup, handleDelGroup } = await import("./commands/group.js");
+  if (await handleGroupCreate(args)) return;
+  if (await handleGroupCommand(args)) return;
+  if (await handleAddToGroup(args)) return;
+  if (await handleResetBan(args)) return;
+  if (await handleLeaveGroup(args)) return;
+  if (await handleDelGroup(args)) return;
+
+  const { handlePort, handleDaemonFlag, handleBareRun } = await import("./commands/daemon.js");
+  if (await handlePort(args)) return;
+  if (await handleDaemonFlag(args, VERSION)) return;
+  if (await handleBareRun(args, VERSION)) return;
+
+  const { startDaemonMain } = await import("./bootstrap.js");
+  await startDaemonMain(VERSION);
+}
+
+export { VERSION };