dsh-multi-router 0.3.8 → 0.4.1

package/lib/{chunk-WIDXMBQ2.js → chunk-DZYRIZW2.js}

@@ -34,13 +34,13 @@ import {
 import { createHash, randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
 
 // package.json
-var version = "0.3.8";
+var version = "0.4.1";
 
 // src/manager.mjs
-import { readFile, mkdir as mkdir2, mkdtemp as mkdtemp2, rm as rm2 } from "node:fs/promises";
+import { readFile as readFile2, mkdir as mkdir2, mkdtemp as mkdtemp2, rm as rm3 } from "node:fs/promises";
 import { watch } from "node:fs";
-import { dirname as dirname3, join as join3, relative as relative2, resolve } from "node:path";
-import { withFileLock } from "@deepseek-ai/dsh-atomic-write";
+import { dirname as dirname3, join as join4, relative as relative2, resolve } from "node:path";
+import { withFileLock as withFileLock2 } from "@deepseek-ai/dsh-atomic-write";
 
 // upstream/qoder/src/status-paths.ts
 var QODER_STATUS_PATH = "/plugins/dsh-qoder-connect/status";
@@ -233,6 +233,400 @@ async function prepareMigration(manager, raw, portable, mode) {
   }
 }
 
+// src/plugin-updates.mjs
+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";
+var WORKBUDDY_UPDATE_PACKAGE_NAME = "dsh-workbuddy-connect";
+var WORKBUDDY_UPDATE_NPM_METADATA_URL = `https://registry.npmjs.org/-/package/${WORKBUDDY_UPDATE_PACKAGE_NAME}/dist-tags`;
+var WORKBUDDY_UPDATE_RELEASES_API_URL = `${WORKBUDDY_REPOSITORY_URL.replace("https://github.com", "https://api.github.com/repos")}/releases?per_page=100`;
+var WORKBUDDY_RELEASE_PAGE_BASE = `${WORKBUDDY_REPOSITORY_URL}/releases/tag/`;
+var WORKBUDDY_UPDATE_MAX_METADATA_BYTES = 64 * 1024;
+var WORKBUDDY_UPDATE_MAX_RELEASES_BYTES = 1024 * 1024;
+function parseWorkBuddyVersion(raw) {
+  if (typeof raw !== "string") return void 0;
+  const normalized = raw.startsWith("v") ? raw.slice(1) : raw;
+  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u.exec(normalized);
+  if (match === null) return void 0;
+  const rawPrerelease = match[4] === void 0 ? [] : match[4].split(".");
+  if (rawPrerelease.some((identifier) => /^\d+$/u.test(identifier) && !/^(0|[1-9]\d*)$/u.test(identifier))) return void 0;
+  const prerelease = rawPrerelease.map((identifier) => /^(0|[1-9]\d*)$/u.test(identifier) ? Number(identifier) : identifier);
+  if (prerelease.some((identifier) => typeof identifier === "number" && !Number.isSafeInteger(identifier))) return void 0;
+  const parsed = {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease
+  };
+  return [parsed.major, parsed.minor, parsed.patch].every(Number.isSafeInteger) ? parsed : void 0;
+}
+function compareIdentifiers(left, right) {
+  if (typeof left === "number" && typeof right === "number") return left < right ? -1 : left > right ? 1 : 0;
+  if (typeof left === "number") return -1;
+  if (typeof right === "number") return 1;
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareWorkBuddyVersions(left, right) {
+  const a = parseWorkBuddyVersion(left);
+  const b = parseWorkBuddyVersion(right);
+  if (a === void 0 || b === void 0) throw new TypeError("invalid WorkBuddy Connect version");
+  for (const [aPart, bPart] of [[a.major, b.major], [a.minor, b.minor], [a.patch, b.patch]]) {
+    if (aPart !== bPart) return aPart < bPart ? -1 : 1;
+  }
+  if (a.prerelease.length === 0 && b.prerelease.length !== 0) return 1;
+  if (a.prerelease.length !== 0 && b.prerelease.length === 0) return -1;
+  for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index += 1) {
+    const aPart = a.prerelease[index];
+    const bPart = b.prerelease[index];
+    if (aPart === void 0) return -1;
+    if (bPart === void 0) return 1;
+    const comparison = compareIdentifiers(aPart, bPart);
+    if (comparison !== 0) return comparison;
+  }
+  return 0;
+}
+
+// src/plugin-updates.mjs
+var packageName = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/i;
+var safeRef = /^[a-zA-Z0-9._/-]{1,200}$/;
+function parsePluginSource(name, spec) {
+  if (!packageName.test(name) || typeof spec !== "string" || spec.length > 600 || spec.startsWith("-") || spec.trim() !== spec || /[\x00-\x1f]/.test(spec)) return { kind: "unsupported" };
+  const git = /^(?:github:|git\+https:\/\/github\.com\/|https:\/\/github\.com\/|git\+ssh:\/\/git@github\.com\/|git@github\.com:)?([\w.-]+)\/([\w.-]+?)(?:\.git)?(?:#(.+))?$/.exec(spec);
+  if (git && !spec.startsWith("@") && !spec.startsWith("file:") && !spec.startsWith("link:")) {
+    const [, owner, repo, ref] = git;
+    if (owner === "." || owner === ".." || repo === "." || repo === ".." || ref && (!safeRef.test(ref) || ref.includes(".."))) return { kind: "unsupported" };
+    return { kind: "github", owner, repo, ref, source: `github:${owner}/${repo}${ref ? "#" + ref : ""}` };
+  }
+  if (/^(?:file:|link:|workspace:|https?:|git|\/|\.)/.test(spec)) return { kind: "unsupported" };
+  const alias = /^npm:((?:@[^/]+\/)?[^@]+)(?:@(.+))?$/.exec(spec);
+  const actual = alias?.[1] ?? name, range = alias?.[2] ?? spec;
+  if (!packageName.test(actual) || !/^[a-zA-Z0-9.*^~<>=|+ -]{1,160}$/.test(range)) return { kind: "unsupported" };
+  const channel = /^[a-zA-Z][\w.-]*$/.test(range);
+  return { kind: "npm", package: actual, alias: !!alias, channel, tag: channel ? range : "latest", source: spec };
+}
+function githubCommit(value) {
+  if (typeof value !== "string") return void 0;
+  return /(?:\/tar\.gz\/|\/tarball\/|#)([a-f0-9]{40})(?:\b|\()/i.exec(value)?.[1]?.toLowerCase();
+}
+async function jsonFile(file) {
+  try {
+    return JSON.parse(await readFile(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function locks(dir) {
+  let pnpm;
+  try {
+    pnpm = parseYaml(await readFile(join3(dir, "pnpm-lock.yaml"), "utf8"), { maxAliasCount: 20 });
+  } catch {
+  }
+  const npm = await jsonFile(join3(dir, "package-lock.json"));
+  const times = await Promise.all(["pnpm-lock.yaml", "package-lock.json"].map((name) => stat(join3(dir, name)).then((s) => s.mtimeMs).catch(() => 0)));
+  return { pnpm, npm, preferNpm: times[1] > times[0] };
+}
+async function publicJson(url, fetchImpl, signal) {
+  const res = await fetchImpl(url, {
+    signal: AbortSignal.any([signal, AbortSignal.timeout(12e3)]),
+    headers: { Accept: "application/json", "User-Agent": "dsh-multi-router-plugin-updates" },
+    redirect: "error"
+  });
+  if (!res.ok) throw Error(res.status === 403 || res.status === 429 ? "\u8FDC\u7AEF\u9650\u6D41\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5" : res.status === 404 ? "\u4ED3\u5E93 / \u7248\u672C\u4E0D\u5B58\u5728\uFF0C\u6216\u9700\u8981\u79C1\u6709\u4ED3\u5E93\u6388\u6743" : `\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF08HTTP ${res.status}\uFF09`);
+  let size = 0, chunks = [];
+  for await (const chunk of res.body) {
+    size += chunk.byteLength;
+    if (size > 256 * 1024) throw Error("\u66F4\u65B0\u5143\u6570\u636E\u8FC7\u5927");
+    chunks.push(Buffer.from(chunk));
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+var short = (sha) => sha?.slice(0, 8);
+async function registryVersion(service, profile, spec, signal) {
+  const require2 = createRequire(profile.installAnchor);
+  const { viewProfilePackage } = await import(pathToFileURL(require2.resolve("@deepseek-ai/dsh-plugin-manager/operations")).href);
+  const { registryPlan } = await import(pathToFileURL(require2.resolve("@deepseek-ai/dsh-plugin-manager/registry")).href);
+  for (const registry of registryPlan(void 0, await service.registries())) {
+    const answer = await viewProfilePackage(profile.dir, spec, { ...profile.packageManager, registry, timeoutMs: 12e3, signal });
+    if (signal.aborted) throw Error("\u68C0\u67E5\u5DF2\u53D6\u6D88");
+    if (answer.exitCode !== 0) continue;
+    const parsed = JSON.parse(answer.stdout), metadata = Array.isArray(parsed) ? parsed.at(-1) : parsed;
+    if (metadata?.version) return metadata;
+  }
+  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, 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 {
+      available: !!this.service()?.listBundles && !!this.profile()?.dir,
+      checkedAt: this.checkedAt,
+      rows: this.rows.map(({ spec, ...row }) => ({ ...row, source: row.source.kind === "unsupported" ? { kind: "unsupported" } : row.source })),
+      job: this.job,
+      error: this.error
+    };
+  }
+  async list() {
+    const service = this.service(), profile = this.profile();
+    if (!service?.listBundles || !profile?.dir) {
+      this.rows = [];
+      return;
+    }
+    const [manifest, bundles, lock] = await Promise.all([jsonFile(join3(profile.dir, "package.json")), service.listBundles(), locks(profile.dir)]);
+    if (!manifest) throw Error("\u5F53\u524D DSH \u914D\u7F6E\u7684\u63D2\u4EF6\u6E05\u5355\u65E0\u6CD5\u8BFB\u53D6");
+    this.rows = bundles.filter((b) => b.installed || b.version).map((b) => {
+      const spec = manifest.dependencies?.[b.name];
+      const source = !spec || b.removable === false && !b.readOnlyReason ? { kind: "builtin" } : parsePluginSource(b.name, spec);
+      const npm = lock.npm?.packages?.[`node_modules/${b.name}`]?.resolved;
+      const pnpm = lock.pnpm?.importers?.["."]?.dependencies?.[b.name]?.version;
+      const installed = lock.preferNpm ? npm ?? pnpm : pnpm ?? npm;
+      const previous = this.rows.find((r) => r.name === b.name && r.spec === spec && r.version === b.version && r.commit === githubCommit(installed));
+      return {
+        ...previous,
+        name: b.name,
+        version: b.version,
+        enabled: b.enabled,
+        spec,
+        source,
+        commit: githubCommit(installed),
+        status: previous?.status ?? (source.kind === "builtin" ? "builtin" : source.kind === "unsupported" ? "unsupported" : "unchecked"),
+        ...source.kind === "builtin" ? { message: "DSH \u81EA\u5E26 / \u53D7\u4FDD\u62A4\u7EC4\u4EF6\uFF0C\u8BF7\u901A\u8FC7\u66F4\u65B0 DeepSeek Harness \u5347\u7EA7" } : {},
+        ...source.kind === "unsupported" ? { message: "\u672C\u5730\u6587\u4EF6 / \u94FE\u63A5\u6765\u6E90\uFF0C\u8BF7\u901A\u8FC7\u539F\u5B89\u88C5\u65B9\u5F0F\u66F4\u65B0" } : {}
+      };
+    });
+  }
+  async checkRow(row) {
+    try {
+      if (row.source.kind === "npm") {
+        const spec = `${row.source.package}@${row.source.tag}`;
+        const found = await this.lookup(this.service(), this.profile(), spec, this.abort.signal);
+        if (!found.version || found.problem && found.problem !== "already-installed") throw Error(found.problem === "not-found" ? "npm \u4E2D\u672A\u627E\u5230\u8BE5\u5305\u6216\u9891\u9053" : "npm \u67E5\u8BE2\u5931\u8D25\uFF1B\u8BF7\u68C0\u67E5 DSH \u7684\u7F51\u7EDC\u4E0E registry \u8BBE\u7F6E");
+        if (!parseWorkBuddyVersion(found.version) || row.version && !parseWorkBuddyVersion(row.version)) throw Error("\u65E0\u6CD5\u6BD4\u8F83\u7248\u672C\u53F7");
+        row.latestVersion = found.version;
+        row.target = `${row.name}@${row.source.alias ? `npm:${row.source.package}@` : ""}${row.source.channel ? row.source.tag : found.version}`;
+        row.status = !row.version || compareWorkBuddyVersions(found.version, row.version) > 0 ? "available" : "current";
+        row.message = !row.version ? "\u5B89\u88C5\u6587\u4EF6\u4E0D\u53EF\u8BFB\uFF0C\u53EF\u91CD\u65B0\u5B89\u88C5\u8BE5\u6765\u6E90\u4FEE\u590D" : row.status === "current" ? "\u5F53\u524D\u7248\u672C\u5DF2\u662F\u8BE5\u9891\u9053\u6700\u65B0\uFF0C\u6216\u9AD8\u4E8E\u8BE5\u9891\u9053" : void 0;
+      } else if (row.source.kind === "github") {
+        const { owner, repo, ref } = row.source;
+        const url = `https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}/commits/${encodeURIComponent(ref ?? "HEAD")}`;
+        const found = await publicJson(url, this.fetchImpl, this.abort.signal);
+        if (!/^[a-f0-9]{40}$/i.test(found.sha)) throw Error("GitHub \u8FD4\u56DE\u65E0\u6548\u63D0\u4EA4\u4FE1\u606F");
+        row.latestCommit = found.sha.toLowerCase();
+        row.target = `${row.name}@${row.spec}`;
+        row.status = row.commit === row.latestCommit ? "current" : "available";
+        row.message = row.commit ? row.status === "available" ? `\u63D0\u4EA4 ${short(row.commit)} \u2192 ${short(row.latestCommit)}` : "\u8BE5\u5206\u652F / \u6807\u7B7E\u7684\u63D0\u4EA4\u5DF2\u540C\u6B65" : "\u65E0\u6CD5\u8BFB\u53D6\u672C\u5730 Git \u63D0\u4EA4\uFF0C\u53EF\u91CD\u65B0\u5B89\u88C5\u5DF2\u68C0\u67E5\u7684\u6765\u6E90";
+        if (ref && /^[a-f0-9]{7,40}$/i.test(ref)) {
+          row.status = "pinned";
+          row.message = "\u5B89\u88C5\u6765\u6E90\u56FA\u5B9A\u5728 Git \u63D0\u4EA4\uFF1B\u4FDD\u7559\u6B64\u63D0\u4EA4\uFF0C\u4E0D\u81EA\u52A8\u5207\u6362\u5206\u652F";
+        }
+      }
+      row.checkedAt = Date.now();
+      row.checkedEnabled = row.enabled;
+    } catch (error) {
+      row.status = "failed";
+      row.message = error.message;
+      delete row.target;
+    }
+  }
+  start(kind, task) {
+    if (this.flight) throw Error("\u5DF2\u6709\u63D2\u4EF6\u64CD\u4F5C\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7B49\u5F85\u5B8C\u6210");
+    this.job = { id: randomUUID(), kind, state: "running", startedAt: Date.now(), results: [], total: 0 };
+    this.error = void 0;
+    this.flight = Promise.resolve().then(() => task(this.job)).then(() => {
+      this.job.state = this.job.cancelRequested ? "cancelled" : "done";
+    }, (e) => {
+      this.job.state = this.job.cancelRequested ? "cancelled" : "failed";
+      this.job.message = e.message;
+    }).finally(() => {
+      this.job.finishedAt = Date.now();
+      this.flight = void 0;
+    });
+  }
+  check() {
+    this.start("check", async (job) => {
+      await this.list();
+      const rows = this.rows.filter((r) => ["npm", "github"].includes(r.source.kind));
+      job.total = rows.length;
+      let next = 0;
+      await Promise.all(Array.from({ length: Math.min(3, rows.length) }, async () => {
+        while (next < rows.length && !job.cancelRequested) {
+          const row = rows[next++];
+          await this.checkRow(row);
+          job.results.push({ name: row.name, status: row.status, message: row.message });
+        }
+      }));
+      this.checkedAt = Date.now();
+    });
+  }
+  async installRow(row, registry) {
+    const original = await jsonFile(join3(this.profile().dir, "package.json"));
+    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 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,
+        status: "failed",
+        application: result.application,
+        message: result.pendingBuilds?.length ? "\u4F9D\u8D56\u6784\u5EFA\u811A\u672C\u9700\u8981\u6388\u6743\uFF0C\u8BF7\u5230 DSH \u63D2\u4EF6\u5B89\u88C5\u9875\u5141\u8BB8\u8FD9\u4E9B\u811A\u672C\u540E\u91CD\u8BD5" : result.error?.code === "incompatible-version" ? "\u63D2\u4EF6\u4E0E\u5F53\u524D DSH \u4E0D\u517C\u5BB9\uFF0C\u8BF7\u5148\u5347\u7EA7 DSH \u6216\u9009\u62E9\u517C\u5BB9\u7248\u672C" : `\u5B89\u88C5\u672A\u5B8C\u6210\uFF08${result.error?.code ?? result.packageResult?.kind ?? "unknown"}\uFF09\uFF1B\u8BF7\u5230 DSH \u63D2\u4EF6\u9875\u67E5\u770B\u5B89\u88C5\u65E5\u5FD7`,
+        pendingBuilds: result.pendingBuilds ?? [],
+        logPath: result.packageResult?.logPath
+      };
+    }
+    const installed = (await this.service().listBundles()).find((b) => b.name === row.name);
+    if (row.source.kind === "npm" && installed?.version !== row.latestVersion) return {
+      name: row.name,
+      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) {
+    if (!Array.isArray(names) || !names.length || names.length > 200 || names.some((n) => typeof n !== "string") || new Set(names).size !== names.length) throw Error("\u8BF7\u9009\u62E9\u8981\u66F4\u65B0\u7684\u63D2\u4EF6");
+    const selected = names.map((name) => this.rows.find((r) => r.name === name));
+    if (selected.some((r) => !r || !["available", "failed"].includes(r.status) || !r.target || Date.now() - r.checkedAt > 6e5)) throw Error("\u8BF7\u5148\u68C0\u67E5\u66F4\u65B0\uFF0C\u518D\u9009\u62E9\u53EF\u66F4\u65B0\u7684\u63D2\u4EF6\uFF08\u68C0\u67E5\u7ED3\u679C\u6709\u6548\u671F 10 \u5206\u949F\uFF09");
+    selected.sort((a, b) => Number(a.name === "dsh-multi-router") - Number(b.name === "dsh-multi-router"));
+    this.start("update", async (job) => {
+      job.total = selected.length;
+      for (const row of selected) {
+        if (job.cancelRequested) break;
+        job.current = row.name;
+        let result;
+        try {
+          result = await this.installRow(row, registry);
+        } catch (e) {
+          result = { name: row.name, status: "failed", message: e.message };
+        }
+        job.results.push(result);
+        row.status = result.status;
+        row.message = result.message;
+      }
+      delete job.current;
+      await this.list();
+    });
+  }
+  install(spec, registry) {
+    if (typeof spec !== "string" || spec.length > 600 || spec.startsWith("-") || /[\s\x00-\x1f]/.test(spec)) throw Error("\u8BF7\u8F93\u5165\u4E00\u4E2A npm \u5305\u540D\u6216 GitHub \u5B89\u88C5\u5730\u5740");
+    const named = /^((?:@[^/]+\/)?[^@]+)(?:@(.+))?$/.exec(spec);
+    const github = parsePluginSource("placeholder", spec);
+    const npm = named && parsePluginSource(named[1], named[2] || "latest");
+    if (github.kind !== "github" && npm?.kind !== "npm") throw Error("\u4EC5\u652F\u6301 npm \u5305\u540D / \u7248\u672C\u6216 github:\u7528\u6237/\u4ED3\u5E93");
+    this.start("install", async (job) => {
+      job.total = 1;
+      job.current = spec;
+      const result = await this.service().installBundle(spec, { requestId: job.id, ...registry ? { registry } : {} });
+      job.results.push({
+        name: result.bundle ?? spec,
+        status: result.error || ["failed", "cancelled"].includes(result.application) || result.packageResult && result.packageResult.exitCode !== 0 ? "failed" : "installed",
+        message: result.error ? `\u5B89\u88C5\u672A\u5B8C\u6210\uFF08${result.error.code}\uFF09\uFF0C\u8BF7\u67E5\u770B DSH \u63D2\u4EF6\u5B89\u88C5\u65E5\u5FD7` : result.application === "restart-required" ? "\u5DF2\u5B89\u88C5\uFF0C\u8BF7\u5B8C\u5168\u9000\u51FA\u5E76\u91CD\u542F DSH" : "\u5B89\u88C5\u5B8C\u6210",
+        application: result.application,
+        pendingBuilds: result.pendingBuilds ?? [],
+        restartRequired: result.application === "restart-required"
+      });
+      delete job.current;
+      await this.list();
+    });
+  }
+  async action(input) {
+    if (!this.state().available) throw Error("\u5F53\u524D DSH \u672A\u63D0\u4F9B\u63D2\u4EF6\u7BA1\u7406\u63A5\u53E3\uFF0C\u8BF7\u5347\u7EA7 DSH \u540E\u91CD\u8BD5");
+    if (input.registry && !["https://registry.npmjs.org/", "https://registry.npmmirror.com/"].includes(input.registry)) throw Error("\u65E0\u6548\u7684 npm \u6765\u6E90");
+    if (input.action === "plugins.list") {
+      if (!this.flight) await this.list();
+    } else if (input.action === "plugins.check") this.check();
+    else if (input.action === "plugins.update") this.update(input.names, input.registry);
+    else if (input.action === "plugins.install") this.install(input.spec, input.registry);
+    else if (input.action === "plugins.cancel") {
+      if (this.job?.state === "running") {
+        this.job.cancelRequested = true;
+        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/manager.mjs
 var MANAGEMENT_PATH = "/.well-known/dsh-multi-router";
 var revisionOf = (raw) => createHash("sha256").update(JSON.stringify(raw)).digest("hex");
@@ -272,28 +666,35 @@ function modelInfo(row) {
 }
 var Manager = class {
   constructor(file, router, onChange = () => {
-  }) {
+  }, pluginAccess = {}) {
     this.file = file;
     this.router = router;
     this.onChange = onChange;
-    this.catalogFile = join3(dirname3(file), "catalogs.json");
+    this.catalogFile = join4(dirname3(file), "catalogs.json");
     this.catalogs = /* @__PURE__ */ new Map();
     this.catalogErrors = /* @__PURE__ */ new Map();
     this.refreshes = /* @__PURE__ */ new Map();
     this.closed = false;
     this.monitorFlights = /* @__PURE__ */ new Map();
     this.loginInfo = /* @__PURE__ */ new Map();
-    this.telemetry = new Telemetry(join3(dirname3(file), "usage.json"));
+    this.telemetry = new Telemetry(join4(dirname3(file), "usage.json"));
+    this.plugins = new PluginUpdates(pluginAccess);
+    this.setupFile = join4(dirname3(file), "initial-setup.json");
     router.telemetry = this.telemetry;
     router.monitor = (a) => this.monitorAccount(a);
     router.prepareFree = () => this.checkFreeModels(true);
     router.freeModels = (account) => this.freeModels(account);
   }
   async load() {
-    this.raw = JSON.parse(await readFile(this.file, "utf8"));
+    this.raw = JSON.parse(await readFile2(this.file, "utf8"));
+    try {
+      this.setup = JSON.parse(await readFile2(this.setupFile, "utf8"));
+    } catch {
+      this.setup = void 0;
+    }
     this.config = validateConfig(this.raw, this.file);
     try {
-      const saved = JSON.parse(await readFile(this.catalogFile, "utf8"));
+      const saved = JSON.parse(await readFile2(this.catalogFile, "utf8"));
       for (const account of this.config.accounts) {
         const item = saved[account.id];
         if (item?.credentialFile === account.credentialFile && Array.isArray(item.models)) {
@@ -333,10 +734,11 @@ var Manager = class {
         ...discovered.status.map((s) => ({ ...s, checkedAt: Date.now() }))
       ];
       if (this.closed || !discovered.accounts.length) return;
-      await withFileLock(this.file, async () => {
+      await withFileLock2(this.file, async () => {
         if (this.closed) return;
-        let raw = JSON.parse(await readFile(this.file, "utf8"));
+        let raw = JSON.parse(await readFile2(this.file, "utf8"));
         let changed = false;
+        const saved = /* @__PURE__ */ new Map();
         for (const item of discovered.accounts) {
           const key = localAccountKey(item.provider, item.document);
           if (!force && raw.ignoredLocalAccounts?.includes(key)) continue;
@@ -353,6 +755,11 @@ var Manager = class {
             } catch {
             }
           }
+          const id = existing?.id ?? `local_${createHash("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);
+          };
           let sameDevice = true;
           if (existing && item.identityDocument) {
             try {
@@ -362,13 +769,15 @@ var Manager = class {
               sameDevice = false;
             }
           }
-          if (existing && sameDevice && current.credential.expiresAtMs >= item.document.credential.expiresAtMs) continue;
-          const id = existing?.id ?? `local_${createHash("sha256").update(key).digest("hex").slice(0, 20)}`;
-          const base = join3(dirname3(this.file), "accounts");
+          if (existing && sameDevice && current.credential.expiresAtMs >= item.document.credential.expiresAtMs) {
+            recordSaved();
+            continue;
+          }
+          const base = join4(dirname3(this.file), "accounts");
           await mkdir2(base, { recursive: true, mode: 448 });
-          const staging = await mkdtemp2(join3(base, `${id}-`));
+          const staging = await mkdtemp2(join4(base, `${id}-`));
           try {
-            const credentialFile = join3(staging, "credential.json"), identityFile = join3(staging, "identity.json");
+            const credentialFile = join4(staging, "credential.json"), identityFile = join4(staging, "identity.json");
             await importAccount({ ...item, credentialFile, identityFile });
             const paths = {
               credentialFile: relative2(dirname3(this.file), credentialFile),
@@ -387,11 +796,12 @@ var Manager = class {
             await writePrivateJson(this.file, next);
             raw = next;
             changed = true;
+            recordSaved();
             this.router.clients.delete(id);
             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);
           }
         }
@@ -401,12 +811,25 @@ var Manager = class {
           await Promise.all(this.config.accounts.map((a) => this.readLogin(a)));
           this.publish();
         }
+        this.localDiscovery = this.localDiscovery.map((s) => discovered.status.some((d) => d.provider === s.provider) ? { ...s, savedCount: saved.get(s.provider)?.size ?? 0 } : s);
       }, { waitMs: 3e4 });
     })().finally(() => {
       this.localScan = void 0;
     });
     return this.localScan;
   }
+  async finishInitialSetup() {
+    if (this.setup?.completedAt) return;
+    await withFileLock2(this.setupFile, async () => {
+      try {
+        this.setup = JSON.parse(await readFile2(this.setupFile, "utf8"));
+      } catch {
+      }
+      if (this.setup?.completedAt) return;
+      this.setup = { completedAt: Date.now(), dismissed: false };
+      await writePrivateJson(this.setupFile, this.setup);
+    });
+  }
   async monitorAccount(account) {
     if (this.monitorFlights.has(account.id)) return this.monitorFlights.get(account.id);
     const promise = (async () => {
@@ -581,7 +1004,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 withFileLock2(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() });
@@ -597,6 +1020,8 @@ var Manager = class {
       pluginVersion: version,
       revision: this.revision,
       localDiscovery: this.localDiscovery ?? [],
+      setup: this.setup,
+      pluginUpdates: this.plugins.state(),
       telemetry: this.telemetry.state(),
       accounts: this.config.accounts.map((a) => ({
         id: a.id,
@@ -631,8 +1056,23 @@ var Manager = class {
   }
   async action(input) {
     if (!input || typeof input !== "object" || Array.isArray(input)) bad("\u8BF7\u6C42\u683C\u5F0F\u65E0\u6548");
+    if (typeof input.action === "string" && input.action.startsWith("plugins.")) {
+      try {
+        await this.plugins.action(input);
+      } catch (e) {
+        bad(e.message);
+      }
+      return this.state();
+    }
+    if (input.action === "setup.dismiss") {
+      await withFileLock2(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 readFile(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 readFile2(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;
@@ -654,7 +1094,7 @@ var Manager = class {
       } };
     }
     if (input.action === "config.export") {
-      if (input.revision !== revisionOf(JSON.parse(await readFile(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 readFile2(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) {
@@ -701,8 +1141,8 @@ var Manager = class {
       await this.checkFreeModels(true);
       return this.state();
     }
-    return withFileLock(this.file, async () => {
-      let raw = JSON.parse(await readFile(this.file, "utf8"));
+    return withFileLock2(this.file, async () => {
+      let raw = JSON.parse(await readFile2(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;
@@ -725,10 +1165,10 @@ var Manager = class {
           }
           if (!/^[a-zA-Z0-9_-]{1,64}$/.test(input.id ?? "") || !PROVIDERS.includes(input.provider)) bad("\u8D26\u53F7 ID \u6216\u4F9B\u5E94\u5546\u65E0\u6548");
           if (account && !replacing) bad("\u8D26\u53F7 ID \u5DF2\u5B58\u5728\uFF0C\u8BF7\u4F7F\u7528\u4E0D\u540C ID");
-          const base = join3(dirname3(this.file), "accounts");
+          const base = join4(dirname3(this.file), "accounts");
           await mkdir2(base, { recursive: true, mode: 448 });
-          staging = await mkdtemp2(join3(base, `${input.id}-`));
-          const credentialFile = join3(staging, "credential.json"), identityFile = join3(staging, "identity.json");
+          staging = await mkdtemp2(join4(base, `${input.id}-`));
+          const credentialFile = join4(staging, "credential.json"), identityFile = join4(staging, "identity.json");
           const added = {
             id: input.id,
             name: input.name || account?.name || input.id,
@@ -888,7 +1328,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) => {
@@ -916,8 +1356,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 readFile(this.file, "utf8"));
+        void withFileLock2(this.file, async () => {
+          const raw = JSON.parse(await readFile2(this.file, "utf8"));
           if (this.closed || revisionOf(raw) === this.revision) return;
           const config = validateConfig(raw, this.file);
           this.raw = raw;
@@ -984,4 +1424,4 @@ export {
   Manager,
   managementHandler
 };
-//# sourceMappingURL=chunk-WIDXMBQ2.js.map
+//# sourceMappingURL=chunk-DZYRIZW2.js.map