dsh-multi-router 0.4.0 → 0.5.0

package/lib/{chunk-UQS7DNOQ.js → chunk-W5WP4ATM.js}

@@ -1,20 +1,20 @@
 import {
   jsonCredential,
   qoderPluginDataDir
-} from "./chunk-UFS7ZJKY.js";
+} from "./chunk-YUP77Q3A.js";
 import {
   discoverLocalAccounts,
   importAccount,
   localAccountKey,
   readPortableCredential
-} from "./chunk-3VGKH7MF.js";
+} from "./chunk-OMG4FZWV.js";
 import {
   hostIsLoopback
 } from "./chunk-DNQPZMPF.js";
 import {
   Telemetry,
   matchModel
-} from "./chunk-GGRCX2NR.js";
+} from "./chunk-XV7O2LRF.js";
 import {
   PROVIDERS,
   PROVIDER_NAMES,
@@ -25,22 +25,22 @@ import {
   routeReasoning,
   validateConfig,
   writePrivateJson
-} from "./chunk-XMXFIV5G.js";
+} from "./chunk-GAQ77CH4.js";
 import {
   modelWithCurrentPromotion
 } from "./chunk-TEZ2FMEO.js";
 
 // src/manager.mjs
-import { createHash, randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
+import { createHash as createHash2, randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
 
 // package.json
-var version = "0.4.0";
+var version = "0.5.0";
 
 // src/manager.mjs
-import { readFile as readFile2, mkdir as mkdir2, mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
+import { readFile as readFile3, mkdir as mkdir2, mkdtemp as mkdtemp2, rm as rm3 } from "node:fs/promises";
 import { watch } from "node:fs";
 import { dirname as dirname3, join as join4, relative as relative2, resolve } from "node:path";
-import { withFileLock } from "@deepseek-ai/dsh-atomic-write";
+import { withFileLock as withFileLock3 } from "@deepseek-ai/dsh-atomic-write";
 
 // upstream/qoder/src/status-paths.ts
 var QODER_STATUS_PATH = "/plugins/dsh-qoder-connect/status";
@@ -101,7 +101,7 @@ function settings(config) {
   return {
     ...pick(config, options),
     models: Object.fromEntries(Object.entries(config.models ?? {}).map(([p, rows]) => [p, Object.fromEntries(Object.entries(rows).map(([id, pref]) => [id, pick(pref, ["name", "visible"])]))])),
-    accounts: config.accounts.map((a) => pick(a, ["id", "provider", "name", "enabled"])),
+    accounts: config.accounts.map((a) => pick(a, ["id", "provider", "name", "enabled", "autoCheckin"])),
     routes: Object.fromEntries(Object.entries(config.routes).map(([id, r]) => [id, {
       ...pick(r, ["name", "visible", "strategy", "contextWindow", "maxTokens", "preferExpiringCredits", "expiringWithinDays", "freeOnly", "freeModels"]),
       targets: r.targets.map((t) => pick(t, ["provider", "account", "model", "models", "weight", "tokenBudget", "creditBudget"]))
@@ -234,12 +234,13 @@ async function prepareMigration(manager, raw, portable, mode) {
 }
 
 // src/plugin-updates.mjs
-import { readFile, stat } from "node:fs/promises";
+import { readFile, stat, rm as rm2 } from "node:fs/promises";
 import { join as join3 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
 import { parse as parseYaml } from "yaml";
+import { withFileLock, writeFileAtomic as writeFileAtomic2 } from "@deepseek-ai/dsh-atomic-write";
 
 // upstream/workbuddy/src/update.ts
 var WORKBUDDY_REPOSITORY_URL = "https://github.com/corrinehu/dsh-workbuddy-connect";
@@ -360,14 +361,63 @@ async function registryVersion(service, profile, spec, signal) {
   }
   throw Error("npm \u67E5\u8BE2\u5931\u8D25\uFF1B\u8BF7\u68C0\u67E5 DSH \u7F51\u7EDC\u3001registry \u8BBE\u7F6E\u6216\u5305\u7684\u8BBF\u95EE\u6743\u9650");
 }
+async function refreshGitPlugin(service, profile, row, options2, signal) {
+  const require2 = createRequire(profile.installAnchor);
+  const { runProfilePnpm } = await import(pathToFileURL(require2.resolve("@deepseek-ai/dsh-plugin-manager/operations")).href);
+  const { registryPlan, attributeFailure } = await import(pathToFileURL(require2.resolve("@deepseek-ai/dsh-plugin-manager/registry")).href);
+  const { classifyInstallFailure } = await import(pathToFileURL(require2.resolve("@deepseek-ai/dsh-plugin-manager")).href);
+  const plan = registryPlan(options2.registry, await service.registries());
+  return withFileLock(join3(profile.dir, "package.json"), async () => {
+    const files = await Promise.all(["package.json", "pnpm-lock.yaml"].map(async (name) => {
+      const path = join3(profile.dir, name);
+      try {
+        return { path, content: await readFile(path, "utf8") };
+      } catch (e) {
+        if (e.code !== "ENOENT") throw e;
+        return { path };
+      }
+    }));
+    const restore = () => Promise.all(files.map((f) => f.content === void 0 ? rm2(f.path, { force: true }) : writeFileAtomic2(f.path, f.content, { mode: 384 })));
+    if (JSON.parse(files[0].content).dependencies?.[row.name] !== row.spec) throw Error("\u5B89\u88C5\u6765\u6E90\u5DF2\u6539\u53D8\uFF0C\u8BF7\u91CD\u65B0\u68C0\u67E5");
+    let result;
+    try {
+      for (const registry of plan) {
+        signal.throwIfAborted();
+        const run = await runProfilePnpm({ ...profile, profile: profile.name }, ["update", row.name, ...registry ? [`--registry=${registry}`] : []], {
+          execution: "service",
+          ...profile.packageManager,
+          signal,
+          outputBytes: 16384,
+          idleTimeoutMs: 6e5,
+          lookupTimeoutMs: 2e4,
+          activateNewBundles: false
+        });
+        if (run.exitCode === 0 && !run.timedOut && !signal.aborted) return { packageResult: run, application: "restart-required" };
+        const kind = classifyInstallFailure({ log: run.output, timedOut: run.timedOut });
+        result = {
+          packageResult: { ...run, kind },
+          application: signal.aborted ? "cancelled" : "failed",
+          ...run.incompatible?.length ? { error: { code: "incompatible-version" } } : {}
+        };
+        await restore();
+        if (signal.aborted || attributeFailure(kind, run.output, { kind: "git", host: "github.com" }) !== "registry") break;
+      }
+      return result;
+    } catch (e) {
+      await restore();
+      throw e;
+    }
+  }, { waitMs: 12e4 });
+}
 var PluginUpdates = class {
-  constructor({ service = () => void 0, profile = () => void 0, fetchImpl = (...args) => fetch(...args), lookup = registryVersion } = {}) {
+  constructor({ service = () => void 0, profile = () => void 0, fetchImpl = (...args) => fetch(...args), lookup = registryVersion, refreshGit = refreshGitPlugin } = {}) {
     this.service = service;
     this.profile = profile;
     this.fetchImpl = fetchImpl;
     this.rows = [];
     this.abort = new AbortController();
     this.lookup = lookup;
+    this.refreshGit = refreshGit;
   }
   state() {
     return {
@@ -475,11 +525,16 @@ var PluginUpdates = class {
     if (original?.dependencies?.[row.name] !== row.spec) throw Error("\u5B89\u88C5\u6765\u6E90\u5DF2\u6539\u53D8\uFF0C\u8BF7\u91CD\u65B0\u68C0\u67E5");
     const current = (await this.service().listBundles()).find((b) => b.name === row.name);
     if (!current || current.enabled !== row.checkedEnabled || current.version !== row.version) throw Error("\u63D2\u4EF6\u7248\u672C\u6216\u542F\u7528\u72B6\u6001\u5DF2\u6539\u53D8\uFF0C\u8BF7\u91CD\u65B0\u68C0\u67E5");
-    const result = await this.service().installBundle(row.target, {
-      enabled: row.enabled,
-      requestId: this.job.id,
-      ...registry ? { registry } : {}
-    });
+    const options2 = { enabled: row.enabled, requestId: this.job.id, ...registry ? { registry } : {} };
+    let result;
+    if (row.source.kind === "github") {
+      this.gitAbort = new AbortController();
+      try {
+        result = await this.refreshGit(this.service(), this.profile(), row, options2, AbortSignal.any([this.abort.signal, this.gitAbort.signal]));
+      } finally {
+        this.gitAbort = void 0;
+      }
+    } else result = await this.service().installBundle(row.target, options2);
     if (result.packageResult && result.packageResult.exitCode !== 0 || ["failed", "cancelled"].includes(result.application) || result.error) {
       return {
         name: row.name,
@@ -496,6 +551,16 @@ var PluginUpdates = class {
       status: "failed",
       message: `\u5B9E\u9645\u5B89\u88C5\u7248\u672C ${installed?.version ?? "\u672A\u77E5"} \u4E0E\u68C0\u67E5\u7248\u672C ${row.latestVersion} \u4E0D\u540C\uFF1B\u8BF7\u7A0D\u540E\u91CD\u65B0\u68C0\u67E5\uFF0C\u53EF\u80FD\u662F\u955C\u50CF\u5C1A\u672A\u540C\u6B65\u6216\u53D1\u884C\u65F6\u95F4\u9650\u5236`
     };
+    if (row.source.kind === "github") {
+      const lock = await locks(this.profile().dir);
+      const pnpm = lock.pnpm?.importers?.["."]?.dependencies?.[row.name]?.version, npm = lock.npm?.packages?.[`node_modules/${row.name}`]?.resolved;
+      if (githubCommit(lock.preferNpm ? npm ?? pnpm : pnpm ?? npm) !== row.latestCommit) return {
+        name: row.name,
+        status: "failed",
+        restartRequired: true,
+        message: "\u5B9E\u9645 Git \u63D0\u4EA4\u4E0E\u68C0\u67E5\u7ED3\u679C\u4E0D\u4E00\u81F4\uFF0C\u8BF7\u91CD\u65B0\u68C0\u67E5\u540E\u91CD\u8BD5\uFF1B\u4E0D\u628A\u4ECD\u505C\u7559\u5728\u65E7\u9501\u6587\u4EF6\u7684\u5B89\u88C5\u62A5\u544A\u4E3A\u6210\u529F"
+      };
+    }
     return { name: row.name, status: "installed", application: result.application, message: result.application === "restart-required" ? "\u5DF2\u5B89\u88C5\uFF0C\u5B8C\u5168\u9000\u51FA\u5E76\u91CD\u65B0\u6253\u5F00 DSH \u540E\u751F\u6548" : "\u5B89\u88C5\u5B8C\u6210", restartRequired: result.application === "restart-required" };
   }
   update(names, registry) {
@@ -555,15 +620,179 @@ var PluginUpdates = class {
     else if (input.action === "plugins.cancel") {
       if (this.job?.state === "running") {
         this.job.cancelRequested = true;
-        if (this.job.kind !== "check") await this.service().cancelInstall?.(this.job.id);
+        if (this.gitAbort) this.gitAbort.abort();
+        else if (this.job.kind !== "check") await this.service().cancelInstall?.(this.job.id);
       }
     } else throw Error("\u672A\u77E5\u63D2\u4EF6\u64CD\u4F5C");
   }
 };
 
+// src/checkins.mjs
+import { createHash } from "node:crypto";
+import { readFile as readFile2 } from "node:fs/promises";
+import { setTimeout as delay } from "node:timers/promises";
+import { withFileLock as withFileLock2 } from "@deepseek-ai/dsh-atomic-write";
+var supportsCheckin = (provider) => ["trae", "qoder", "qoder-global"].includes(provider);
+var hash = (value) => createHash("sha256").update(value).digest("hex");
+var nextDay = (now) => Date.parse(`${beijingDay(now)}T00:00:00+08:00`) + 864e5;
+var checkinMessages = {
+  claimed: "\u7B7E\u5230\u6210\u529F",
+  "already-claimed": "\u4ECA\u65E5\u5DF2\u9886\u53D6",
+  "device-used": "\u6B64\u8BBE\u5907\u4ECA\u65E5\u5DF2\u53C2\u4E0E\u7B7E\u5230\uFF0C\u4E0D\u518D\u5207\u6362\u5176\u4ED6\u8D26\u53F7\u9886\u53D6",
+  "no-campaign": "\u5E73\u53F0\u672A\u5F00\u653E\u53EF\u9886\u53D6\u6D3B\u52A8",
+  "before-window": "\u7B7E\u5230\u7A97\u53E3\u5C1A\u672A\u5F00\u542F",
+  paused: "\u5E73\u53F0\u9650\u5236\u6216\u9700\u8981\u9A8C\u8BC1\uFF0C\u5DF2\u6682\u505C\u6B64\u5E73\u53F0\u7B7E\u5230\uFF0C\u8BF7\u5728\u5B98\u65B9\u5BA2\u6237\u7AEF\u5904\u7406",
+  uncertain: "\u8BF7\u6C42\u7ED3\u679C\u5F85\u786E\u8BA4\uFF0C\u4ECA\u65E5\u4E0D\u518D\u81EA\u52A8\u63D0\u4EA4\uFF0C\u8BF7\u5728\u5B98\u65B9\u5BA2\u6237\u7AEF\u6838\u5BF9",
+  error: "\u7B7E\u5230\u672A\u5B8C\u6210\uFF0C\u4ECA\u65E5\u4E0D\u518D\u91CD\u590D\u5C1D\u8BD5\uFF0C\u8BF7\u5728\u5B98\u65B9\u5BA2\u6237\u7AEF\u67E5\u770B",
+  unsupported: "\u6682\u672A\u63A5\u5165\u53EF\u6838\u9A8C\u7684\u7B7E\u5230\u63A5\u53E3\uFF0C\u8BF7\u4F7F\u7528\u5B98\u65B9\u5BA2\u6237\u7AEF"
+};
+var Checkins = class {
+  constructor(file, manager, { now = Date.now, spacingMs = 1e4 } = {}) {
+    this.file = file;
+    this.manager = manager;
+    this.now = now;
+    this.spacingMs = spacingMs;
+    this.data = { records: {}, devices: {}, pauses: {} };
+    this.abort = new AbortController();
+  }
+  async read() {
+    try {
+      const raw = JSON.parse(await readFile2(this.file, "utf8"));
+      const object = (value) => value && typeof value === "object" && !Array.isArray(value);
+      if (!object(raw) || !["records", "devices", "pauses"].every((k) => object(raw[k])) || Object.values(raw.records).some((r) => !object(r) || !Array.isArray(r.ids) || !Number.isFinite(r.at) || typeof r.day !== "string")) throw Error("Invalid check-in journal");
+      this.data = raw;
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+  }
+  async load() {
+    try {
+      await this.read();
+    } catch {
+      this.failed = true;
+    }
+  }
+  state() {
+    return {
+      running: !!this.flight,
+      current: this.current,
+      error: this.failed ? "\u7B7E\u5230\u8BB0\u5F55\u65E0\u6CD5\u8BFB\u53D6\uFF0C\u5DF2\u505C\u6B62\u7B7E\u5230\uFF1B\u8BF7\u4FEE\u590D\u8BB0\u5F55\u6587\u4EF6\u540E\u91CD\u542F\u63D2\u4EF6\u3002" : void 0,
+      schedule: "\u5317\u4EAC\u65F6\u95F4\u6BCF\u5929 10:05 \u540E\uFF0CDSH \u8FD0\u884C\u65F6\u6267\u884C\uFF1B\u9519\u8FC7\u540E\u4E0B\u6B21\u542F\u52A8\u8865\u67E5",
+      accounts: this.manager.config.accounts.map((a) => {
+        const rows = Object.values(this.data.records).filter((r) => r.ids?.includes(a.id));
+        const last = rows.sort((a2, b) => b.at - a2.at)[0];
+        const pause = this.data.pauses[a.provider];
+        return {
+          id: a.id,
+          supported: supportsCheckin(a.provider),
+          auto: a.autoCheckin === true,
+          paused: !!pause,
+          last: last ? {
+            day: last.day,
+            at: last.at,
+            status: last.status,
+            amount: last.amount,
+            message: checkinMessages[last.status] || checkinMessages.error
+          } : void 0
+        };
+      })
+    };
+  }
+  start(ids, automatic = false) {
+    if (this.failed || this.abort.signal.aborted || this.flight) return;
+    if (!automatic && (!Array.isArray(ids) || !ids.length || ids.length > 200 || ids.some((id) => !this.manager.config.accounts.some((a) => a.id === id)))) throw Error("\u8BF7\u9009\u62E9\u6709\u6548\u7684\u7B7E\u5230\u8D26\u53F7");
+    const selected = this.manager.config.accounts.filter((a) => supportsCheckin(a.provider) && a.enabled !== false && (automatic ? a.autoCheckin === true : ids.includes(a.id))).map((a) => a.id);
+    if (!selected.length) return;
+    this.flight = (async () => {
+      let requested = false;
+      for (const id of selected) {
+        if (this.abort.signal.aborted) break;
+        const account = this.manager.config.accounts.find((a) => a.id === id && a.enabled !== false && (!automatic || a.autoCheckin === true));
+        if (!account) continue;
+        if (requested) {
+          await delay(this.spacingMs, void 0, { signal: this.abort.signal });
+          requested = false;
+        }
+        this.current = id;
+        requested = await this.run(account, automatic);
+      }
+    })().catch(() => {
+      if (!this.abort.signal.aborted) this.failed = true;
+    }).finally(() => {
+      this.flight = void 0;
+      this.current = void 0;
+    });
+  }
+  async resume(provider) {
+    if (!supportsCheckin(provider) || this.failed || this.flight) throw Error("\u8BF7\u7B49\u5F85\u7B7E\u5230\u5B8C\u6210\uFF0C\u6216\u5148\u4FEE\u590D\u7B7E\u5230\u8BB0\u5F55");
+    await withFileLock2(this.file, async () => {
+      await this.read();
+      delete this.data.pauses[provider];
+      await writePrivateJson(this.file, this.data);
+    });
+  }
+  async run(account, automatic = false) {
+    const now = this.now(), day = beijingDay(now);
+    if (now < Date.parse(`${day}T10:05:00+08:00`)) return false;
+    return withFileLock2(this.file, async () => {
+      await this.read();
+      if (this.abort.signal.aborted || this.data.pauses[account.provider]) return false;
+      if (Object.values(this.data.records).some((r) => r.day === day && r.ids?.includes(account.id))) return false;
+      if (this.data.lastRequestAt && now - this.data.lastRequestAt < this.spacingMs) return false;
+      this.data.lastRequestAt = now;
+      await writePrivateJson(this.file, this.data);
+      const client = await this.manager.router.client(account);
+      if (!client.checkin) return false;
+      let identity;
+      try {
+        identity = await client.checkin.identity(AbortSignal.any([this.abort.signal, AbortSignal.timeout(3e4)]));
+      } catch {
+        this.data.pauses[account.provider] = { at: now };
+        await writePrivateJson(this.file, this.data);
+        return true;
+      }
+      if (!identity?.account || account.provider === "trae" && !identity.device) throw Error("Missing check-in identity");
+      if (this.abort.signal.aborted || !this.manager.config.accounts.some((a) => a.id === account.id && a.enabled !== false && a.credentialFile === account.credentialFile && (!automatic || a.autoCheckin === true))) return true;
+      const key = hash(`${account.provider}:${identity.account}`), device = identity.device ? hash(`${account.provider}:${identity.device}`) : void 0;
+      const old = this.data.records[key];
+      if (old?.day === day) {
+        if (!old.ids.includes(account.id)) {
+          old.ids.push(account.id);
+          await writePrivateJson(this.file, this.data);
+        }
+        return true;
+      }
+      const record = { day, at: now, status: "uncertain", ids: [account.id] };
+      this.data.records[key] = record;
+      for (const [k, row] of Object.entries(this.data.records)) if (row.at < now - 30 * 864e5) delete this.data.records[k];
+      for (const [k, row] of Object.entries(this.data.devices)) if (row.until <= now) delete this.data.devices[k];
+      if (device && this.data.devices[device]?.until > now) {
+        record.status = "device-used";
+        await writePrivateJson(this.file, this.data);
+        return true;
+      }
+      if (device) this.data.devices[device] = { until: nextDay(now) };
+      await writePrivateJson(this.file, this.data);
+      let result;
+      try {
+        result = await client.checkin.claim(AbortSignal.any([this.abort.signal, AbortSignal.timeout(3e4)]));
+      } catch {
+        result = { status: "uncertain" };
+      }
+      record.status = Object.hasOwn(checkinMessages, result?.status) ? result.status : "uncertain";
+      if (device && ["already-claimed", "no-campaign"].includes(record.status)) delete this.data.devices[device];
+      if (["claimed", "already-claimed"].includes(record.status) && Number.isFinite(result.amount) && result.amount >= 0) record.amount = result.amount;
+      if (record.status === "paused") this.data.pauses[account.provider] = { at: now };
+      await writePrivateJson(this.file, this.data);
+      if (record.status === "claimed") await this.manager.monitorAccount(account);
+      return true;
+    }, { waitMs: 1e3 });
+  }
+};
+
 // src/manager.mjs
 var MANAGEMENT_PATH = "/.well-known/dsh-multi-router";
-var revisionOf = (raw) => createHash("sha256").update(JSON.stringify(raw)).digest("hex");
+var revisionOf = (raw) => createHash2("sha256").update(JSON.stringify(raw)).digest("hex");
 var ManagementError = class extends Error {
   constructor(status, message) {
     super(message);
@@ -613,6 +842,7 @@ var Manager = class {
     this.loginInfo = /* @__PURE__ */ new Map();
     this.telemetry = new Telemetry(join4(dirname3(file), "usage.json"));
     this.plugins = new PluginUpdates(pluginAccess);
+    this.checkins = new Checkins(join4(dirname3(file), "checkins.json"), this);
     this.setupFile = join4(dirname3(file), "initial-setup.json");
     router.telemetry = this.telemetry;
     router.monitor = (a) => this.monitorAccount(a);
@@ -620,15 +850,16 @@ var Manager = class {
     router.freeModels = (account) => this.freeModels(account);
   }
   async load() {
-    this.raw = JSON.parse(await readFile2(this.file, "utf8"));
+    this.raw = JSON.parse(await readFile3(this.file, "utf8"));
     try {
-      this.setup = JSON.parse(await readFile2(this.setupFile, "utf8"));
+      this.setup = JSON.parse(await readFile3(this.setupFile, "utf8"));
     } catch {
       this.setup = void 0;
     }
     this.config = validateConfig(this.raw, this.file);
+    await this.checkins.load();
     try {
-      const saved = JSON.parse(await readFile2(this.catalogFile, "utf8"));
+      const saved = JSON.parse(await readFile3(this.catalogFile, "utf8"));
       for (const account of this.config.accounts) {
         const item = saved[account.id];
         if (item?.credentialFile === account.credentialFile && Array.isArray(item.models)) {
@@ -668,9 +899,9 @@ var Manager = class {
         ...discovered.status.map((s) => ({ ...s, checkedAt: Date.now() }))
       ];
       if (this.closed || !discovered.accounts.length) return;
-      await withFileLock(this.file, async () => {
+      await withFileLock3(this.file, async () => {
         if (this.closed) return;
-        let raw = JSON.parse(await readFile2(this.file, "utf8"));
+        let raw = JSON.parse(await readFile3(this.file, "utf8"));
         let changed = false;
         const saved = /* @__PURE__ */ new Map();
         for (const item of discovered.accounts) {
@@ -689,7 +920,7 @@ var Manager = class {
             } catch {
             }
           }
-          const id = existing?.id ?? `local_${createHash("sha256").update(key).digest("hex").slice(0, 20)}`;
+          const id = existing?.id ?? `local_${createHash2("sha256").update(key).digest("hex").slice(0, 20)}`;
           const recordSaved = () => {
             if (!saved.has(item.provider)) saved.set(item.provider, /* @__PURE__ */ new Set());
             saved.get(item.provider).add(id);
@@ -735,7 +966,7 @@ var Manager = class {
             this.catalogs.delete(id);
             this.catalogErrors.delete(id);
           } catch (e) {
-            await rm2(staging, { recursive: true, force: true });
+            await rm3(staging, { recursive: true, force: true });
             this.localDiscovery = this.localDiscovery.map((s) => s.provider === item.provider ? { ...s, state: "unreadable", code: "import_failed" } : s);
           }
         }
@@ -754,9 +985,9 @@ var Manager = class {
   }
   async finishInitialSetup() {
     if (this.setup?.completedAt) return;
-    await withFileLock(this.setupFile, async () => {
+    await withFileLock3(this.setupFile, async () => {
       try {
-        this.setup = JSON.parse(await readFile2(this.setupFile, "utf8"));
+        this.setup = JSON.parse(await readFile3(this.setupFile, "utf8"));
       } catch {
       }
       if (this.setup?.completedAt) return;
@@ -823,7 +1054,7 @@ var Manager = class {
     for (const account of this.config.accounts.filter((a) => a.enabled !== false)) {
       for (const model of this.freeModels(account)) {
         if (!row.targets.some((t) => t.provider === account.provider && (!t.account || t.account === account.id) && (!t.model || t.model === model.id) && (!t.models || t.models.includes(model.id)))) continue;
-        const id = `free_${createHash("sha256").update(JSON.stringify([parentId, account.provider, model.id])).digest("hex").slice(0, 24)}`;
+        const id = `free_${createHash2("sha256").update(JSON.stringify([parentId, account.provider, model.id])).digest("hex").slice(0, 24)}`;
         if (!groups.has(id)) groups.set(id, { id, models: [], targets: [], accountNames: [], modelName: model.name, provider: account.provider, modelId: model.id });
         const group = groups.get(id);
         group.models.push({ model, provider: account.provider });
@@ -938,7 +1169,7 @@ var Manager = class {
         if (this.closed || !this.config.accounts.some((a) => a.id === account.id && a.credentialFile === account.credentialFile)) return;
         this.catalogs.set(account.id, { credentialFile: account.credentialFile, fetchedAt: Date.now(), pricingVersion: 1, models });
         this.catalogErrors.delete(account.id);
-        await withFileLock(this.catalogFile, () => writePrivateJson(this.catalogFile, Object.fromEntries(this.catalogs)));
+        await withFileLock3(this.catalogFile, () => writePrivateJson(this.catalogFile, Object.fromEntries(this.catalogs)));
       } catch (error) {
         if (this.closed || !this.config.accounts.some((a) => a.id === account.id)) return;
         this.catalogErrors.set(account.id, { status: Number(error.status ?? error.failure?.status) || 502, code: "catalog_fetch_failed", at: Date.now() });
@@ -956,6 +1187,7 @@ var Manager = class {
       localDiscovery: this.localDiscovery ?? [],
       setup: this.setup,
       pluginUpdates: this.plugins.state(),
+      checkins: this.checkins.state(),
       telemetry: this.telemetry.state(),
       accounts: this.config.accounts.map((a) => ({
         id: a.id,
@@ -990,6 +1222,22 @@ var Manager = class {
   }
   async action(input) {
     if (!input || typeof input !== "object" || Array.isArray(input)) bad("\u8BF7\u6C42\u683C\u5F0F\u65E0\u6548");
+    if (input.action === "checkins.run") {
+      try {
+        this.checkins.start(input.ids);
+      } catch (e) {
+        bad(e.message);
+      }
+      return this.state();
+    }
+    if (input.action === "checkins.resume") {
+      try {
+        await this.checkins.resume(input.provider);
+      } catch (e) {
+        bad(e.message);
+      }
+      return this.state();
+    }
     if (typeof input.action === "string" && input.action.startsWith("plugins.")) {
       try {
         await this.plugins.action(input);
@@ -999,14 +1247,14 @@ var Manager = class {
       return this.state();
     }
     if (input.action === "setup.dismiss") {
-      await withFileLock(this.setupFile, async () => {
+      await withFileLock3(this.setupFile, async () => {
         this.setup = { ...this.setup, completedAt: this.setup?.completedAt ?? Date.now(), dismissed: true };
         await writePrivateJson(this.setupFile, this.setup);
       });
       return this.state();
     }
     if (input.action === "account.export") {
-      if (input.revision !== revisionOf(JSON.parse(await readFile2(this.file, "utf8")))) throw new ManagementError(409, "\u914D\u7F6E\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u540E\u63D0\u53D6\u51ED\u8BC1");
+      if (input.revision !== revisionOf(JSON.parse(await readFile3(this.file, "utf8")))) throw new ManagementError(409, "\u914D\u7F6E\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u540E\u63D0\u53D6\u51ED\u8BC1");
       const account = this.config.accounts.find((a) => a.id === input.id);
       if (!account) bad("\u8D26\u53F7\u4E0D\u5B58\u5728");
       let credential;
@@ -1028,7 +1276,7 @@ var Manager = class {
       } };
     }
     if (input.action === "config.export") {
-      if (input.revision !== revisionOf(JSON.parse(await readFile2(this.file, "utf8")))) throw new ManagementError(409, "\u914D\u7F6E\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u540E\u5BFC\u51FA");
+      if (input.revision !== revisionOf(JSON.parse(await readFile3(this.file, "utf8")))) throw new ManagementError(409, "\u914D\u7F6E\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u540E\u5BFC\u51FA");
       try {
         return { ...this.state(), exported: { filename: `dsh-multi-router-${input.includeCredentials ? "encrypted" : "settings"}-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.json`, document: await exportConfiguration(this, input) } };
       } catch (e) {
@@ -1075,8 +1323,8 @@ var Manager = class {
       await this.checkFreeModels(true);
       return this.state();
     }
-    return withFileLock(this.file, async () => {
-      let raw = JSON.parse(await readFile2(this.file, "utf8"));
+    return withFileLock3(this.file, async () => {
+      let raw = JSON.parse(await readFile3(this.file, "utf8"));
       if (input.revision !== revisionOf(raw)) throw new ManagementError(409, "\u914D\u7F6E\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u5237\u65B0\u540E\u518D\u4FDD\u5B58");
       raw.routes ??= structuredClone(this.config.routes);
       let staging;
@@ -1169,6 +1417,10 @@ var Manager = class {
           if (!input.name && !replacing) added.name = imported.credential?.nickname || imported.credential?.accountName || input.id;
         } else if (input.action === "account.update") {
           if (!account) bad("\u8D26\u53F7\u4E0D\u5B58\u5728");
+          if (input.autoCheckin !== void 0) {
+            if (typeof input.autoCheckin !== "boolean" || !supportsCheckin(account.provider)) bad("\u6B64\u5E73\u53F0\u6682\u4E0D\u652F\u6301\u81EA\u52A8\u7B7E\u5230");
+            account.autoCheckin = input.autoCheckin;
+          }
           if (input.name !== void 0) account.name = input.name;
           if (input.enabled !== void 0) account.enabled = input.enabled;
         } else if (input.action === "account.move") {
@@ -1262,7 +1514,7 @@ var Manager = class {
         this.publish();
         await this.telemetry.persist();
       } finally {
-        if (staging) await rm2(staging, { recursive: true, force: true });
+        if (staging) await rm3(staging, { recursive: true, force: true });
       }
       return this.state();
     }, { waitMs: 3e4 }).then(async (state) => {
@@ -1290,8 +1542,8 @@ var Manager = class {
       if (filename && String(filename) !== this.file.split(/[\\/]/).pop()) return;
       clearTimeout(timer);
       timer = setTimeout(() => {
-        void withFileLock(this.file, async () => {
-          const raw = JSON.parse(await readFile2(this.file, "utf8"));
+        void withFileLock3(this.file, async () => {
+          const raw = JSON.parse(await readFile3(this.file, "utf8"));
           if (this.closed || revisionOf(raw) === this.revision) return;
           const config = validateConfig(raw, this.file);
           this.raw = raw;
@@ -1358,4 +1610,4 @@ export {
   Manager,
   managementHandler
 };
-//# sourceMappingURL=chunk-UQS7DNOQ.js.map
+//# sourceMappingURL=chunk-W5WP4ATM.js.map