@androidsup/dsh-plugin-updates 0.0.0-stage → 0.1.1

package/lib/index.js

@@ -0,0 +1,641 @@
+// src/index.mjs
+import { join as join2 } from "node:path";
+
+// src/plugin-updates.mjs
+import { readFile, stat, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { parse as parseYaml, parseDocument, isMap, isSeq, isScalar } from "yaml";
+import { withFileLock, writeFileAtomic as writeFileAtomic2 } from "@deepseek-ai/dsh-atomic-write";
+
+// src/storage.mjs
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { writeFileAtomic } from "@deepseek-ai/dsh-atomic-write";
+async function writePrivateJson(file, value) {
+  await mkdir(dirname(file), { recursive: true, mode: 448 });
+  await writeFileAtomic(file, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+}
+
+// src/activation.mjs
+function outsideActivation(hmr, operation) {
+  const scope = hmr?.executing;
+  return typeof scope?.exit === "function" ? scope.exit(operation) : operation();
+}
+
+// src/version.mjs
+function parseVersion(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 compareVersions(left, right) {
+  const a = parseVersion(left);
+  const b = parseVersion(right);
+  if (a === void 0 || b === void 0) throw new TypeError("invalid plugin 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(name2, spec) {
+  if (!packageName.test(name2) || 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] ?? name2, 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(join(dir, "pnpm-lock.yaml"), "utf8"), { maxAliasCount: 20 });
+  } catch {
+  }
+  const npm = await jsonFile(join(dir, "package-lock.json"));
+  const times = await Promise.all(["pnpm-lock.yaml", "package-lock.json"].map((name2) => stat(join(dir, name2)).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)]),
+    // Request only the SHA: the default JSON includes file patches and can be megabytes.
+    headers: { Accept: "application/vnd.github.sha", "User-Agent": "dsh-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));
+  }
+  const text = Buffer.concat(chunks).toString("utf8").trim();
+  return /^[a-f0-9]{40}$/i.test(text) ? { sha: text } : JSON.parse(text);
+}
+var short = (sha) => sha?.slice(0, 8);
+var reviewedVersion = (row) => row.source.kind === "npm" && parseVersion(row.latestVersion) ? `${row.source.package}@${row.latestVersion}` : void 0;
+async function allowReviewedVersion(profile, row) {
+  const file = join(profile.dir, "pnpm-workspace.yaml"), prefix = `${row.source.package}@`;
+  try {
+    await withFileLock(file, async () => {
+      let text;
+      try {
+        text = await readFile(file, "utf8");
+      } catch (e) {
+        if (e.code !== "ENOENT") throw e;
+        text = "{}\n";
+      }
+      const doc = parseDocument(text), entries = doc.get("minimumReleaseAgeExclude");
+      if (doc.errors.length || !isMap(doc.contents) || entries !== void 0 && (!isSeq(entries) || entries.anchor || entries.items.some((x) => !isScalar(x) || typeof x.value !== "string" || x.anchor))) throw Error("invalid-policy");
+      const values = entries?.items.map((x) => x.value) ?? [];
+      const existing = values.filter((x) => x.startsWith(prefix));
+      const versions = [.../* @__PURE__ */ new Set([...existing.flatMap((x) => x.slice(prefix.length).split(/\s*\|\|\s*/)), row.latestVersion])];
+      const merged = prefix + versions.join(" || ");
+      if (existing.length === 1 && existing[0] === merged) return;
+      if (!entries) doc.set("minimumReleaseAgeExclude", [merged]);
+      else {
+        const first = entries.items.findIndex((x) => x.value.startsWith(prefix));
+        if (first < 0) entries.add(merged);
+        else {
+          entries.items[first].value = merged;
+          for (let i = entries.items.length - 1; i > first; i--) if (entries.items[i].value.startsWith(prefix)) entries.delete(i);
+        }
+      }
+      await writeFileAtomic2(file, String(doc), { mode: 384 });
+    }, { waitMs: 12e4 });
+  } catch {
+    throw Error("\u65E0\u6CD5\u4FDD\u5B58\u6B64\u7248\u672C\u7684\u7B49\u5F85\u671F\u4F8B\u5916\u914D\u7F6E\uFF1B\u8BF7\u68C0\u67E5\u5F53\u524D DSH \u914D\u7F6E\u76EE\u5F55\u6743\u9650\u53CA pnpm-workspace.yaml \u683C\u5F0F\u3002\u672A\u5173\u95ED\u7B49\u5F85\u671F\u4FDD\u62A4\u3002");
+  }
+}
+var installFailed = (r) => !!(r.error || ["failed", "cancelled"].includes(r.application) || r.packageResult && r.packageResult.exitCode !== 0);
+function installFailure(result) {
+  const text = [result.error?.diagnostic, result.packageResult?.output, result.packageResult?.kind].filter((v) => typeof v === "string").join("\n");
+  let reason = "unknown", message = "\u5B89\u88C5\u672A\u5B8C\u6210\uFF1B\u8BF7\u5728 DSH \u539F\u751F\u63D2\u4EF6\u9875\u67E5\u770B\u5B89\u88C5\u65E5\u5FD7\uFF0C\u6216\u590D\u5236\u4E0B\u65B9\u8BCA\u65AD\u4FE1\u606F\u3002";
+  if (result.application === "cancelled") {
+    reason = "cancelled";
+    message = "\u5B89\u88C5\u5DF2\u53D6\u6D88\uFF0C\u53EF\u91CD\u65B0\u68C0\u67E5\u540E\u91CD\u8BD5\u3002";
+  } else if (/ERR_PNPM_(?:MINIMUM_RELEASE_AGE_VIOLATION|NO_MATURE_MATCHING_VERSION)|minimumReleaseAge/i.test(text)) {
+    reason = "release-age";
+    message = "\u65B0\u5305\u5C1A\u5728\u5B89\u88C5\u5668\u7B49\u5F85\u671F\u5185\u3002\u53EF\u5728\u300C\u67E5\u770B\u5E76\u66F4\u65B0\u300D\u4E2D\u52FE\u9009\u300C\u5141\u8BB8\u672C\u6B21\u6307\u5B9A\u7248\u672C\u7ACB\u5373\u5B89\u88C5\u300D\u540E\u91CD\u8BD5\uFF1B\u53EA\u653E\u884C\u786E\u8BA4\u7684\u63D2\u4EF6\u7248\u672C\uFF0C\u4F9D\u8D56\u4ECD\u9700\u6EE1\u8DB3\u7B49\u5F85\u671F\u3002\u4E5F\u53EF\u7B49\u5F85\u5230\u671F\u518D\u5B89\u88C5\u3002";
+  } else if (result.pendingBuilds?.length) {
+    reason = "build";
+    message = "\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\u3002";
+  } else if (result.error?.code === "incompatible-version") {
+    reason = "compatibility";
+    message = "\u63D2\u4EF6\u4E0E\u5F53\u524D DSH \u4E0D\u517C\u5BB9\uFF0C\u8BF7\u5148\u5347\u7EA7 DSH \u6216\u9009\u62E9\u517C\u5BB9\u7248\u672C\u3002";
+  } else if (/\b(?:EPERM|EBUSY|EACCES)\b|resource busy|file.*(?:locked|in use)/i.test(text)) {
+    reason = "files";
+    message = "\u63D2\u4EF6\u6587\u4EF6\u88AB\u5360\u7528\u6216\u76EE\u5F55\u6743\u9650\u4E0D\u8DB3\uFF0C\u5B89\u88C5\u672A\u5B8C\u6210\u3002\u8BF7\u5148\u5728 DSH \u505C\u7528\u8BE5\u63D2\u4EF6\u540E\u91CD\u8BD5\uFF0C\u5E76\u68C0\u67E5\u5B89\u88C5\u76EE\u5F55\u6743\u9650\uFF1B\u4ECD\u88AB\u5360\u7528\u65F6\u9700\u9000\u51FA\u6258\u76D8\u5E94\u7528\u3002";
+  } else if (/HMR transactions cannot be nested|activation|did not activate|entry.*activate/i.test(text)) {
+    reason = "activation";
+    message = "\u63D2\u4EF6\u52A0\u8F7D\u5931\u8D25\u3002\u8BF7\u68C0\u67E5 DSH \u63D2\u4EF6\u9875\u7684\u7EC4\u4EF6\u9519\u8BEF\uFF0C\u518D\u5173\u95ED\u5E76\u91CD\u65B0\u542F\u7528\uFF1B\u5B89\u88C5\u4E0E\u52A0\u8F7D\u662F\u4E24\u4E2A\u72EC\u7ACB\u6B65\u9AA4\u3002";
+  } else if (result.packageResult?.timedOut || /\b(?:ETIMEDOUT|ECONNRESET|ENOTFOUND|EAI_AGAIN|ECONNREFUSED)\b|network|fetch|download/i.test(text)) {
+    reason = "network";
+    message = "\u63D2\u4EF6\u4E0B\u8F7D\u6216\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF0C\u5B89\u88C5\u672A\u5B8C\u6210\u3002npm \u6765\u6E90\u53EF\u5207\u6362\u5230\u300Cnpm \u5B98\u65B9\u300D\u540E\u91CD\u8BD5\uFF1BGitHub \u6765\u6E90\u8BF7\u68C0\u67E5 GitHub \u7F51\u7EDC\u8FDE\u63A5\u3002";
+  }
+  const code = /\b(?:ERR_PNPM_MINIMUM_RELEASE_AGE_VIOLATION|ERR_PNPM_NO_MATURE_MATCHING_VERSION|EPERM|EBUSY|EACCES|ETIMEDOUT|ECONNRESET|ENOTFOUND|EAI_AGAIN|ECONNREFUSED)\b/.exec(text)?.[0] ?? (["operation-error", "incompatible-version"].includes(result.error?.code) ? result.error.code : "unknown");
+  return { status: "failed", application: result.application, message, diagnostic: {
+    reason,
+    code,
+    platform: process.platform,
+    stage: reason === "activation" ? "activation" : "install",
+    ...Number.isInteger(result.packageResult?.exitCode) ? { exitCode: result.packageResult.exitCode } : {}
+  } };
+}
+async function registryVersion(service, profile, spec, signal, requestedRegistry) {
+  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(requestedRegistry, 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 refreshProfilePlugin(service, profile, row, options, 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(options.registry, await service.registries());
+  return withFileLock(join(profile.dir, "package.json"), async () => {
+    const files = await Promise.all(["package.json", "pnpm-lock.yaml"].map(async (name2) => {
+      const path = join(profile.dir, name2);
+      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 ? rm(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.source.kind === "github" ? row.name : row.target, ...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, row.source.kind === "github" ? { kind: "git", host: "github.com" } : { kind: "npm" }) !== "registry") break;
+      }
+      return result;
+    } catch (e) {
+      await restore();
+      throw e;
+    }
+  }, { waitMs: 12e4 });
+}
+var PluginUpdates = class {
+  constructor({ service = () => void 0, profile = () => void 0, hmr = () => void 0, fetchImpl = (...args) => fetch(...args), lookup = registryVersion, refreshPackage = refreshProfilePlugin, onInstalled, stateFile, selfName = "@androidsup/dsh-plugin-updates", now = Date.now } = {}) {
+    this.selfName = selfName;
+    this.stateFile = stateFile;
+    this.now = now;
+    this.dismissed = {};
+    this.ignored = /* @__PURE__ */ new Set();
+    this.lastAttempt = 0;
+    this.saveQueue = Promise.resolve();
+    this.service = service;
+    this.profile = profile;
+    this.hmr = hmr;
+    this.fetchImpl = fetchImpl;
+    this.rows = [];
+    this.abort = new AbortController();
+    this.lookup = lookup;
+    this.refreshPackage = refreshPackage;
+    this.onInstalled = onInstalled;
+  }
+  async load() {
+    const saved = this.stateFile && await jsonFile(this.stateFile);
+    if (saved?.version === 1) {
+      this.lastAttempt = Number.isFinite(saved.lastAttempt) ? saved.lastAttempt : 0;
+      this.checkedAt = saved.checkedAt;
+      this.dismissed = saved.dismissed && typeof saved.dismissed === "object" && !Array.isArray(saved.dismissed) ? saved.dismissed : {};
+      this.rows = Array.isArray(saved.rows) ? saved.rows.filter((r) => ["github", "npm"].includes(r.source?.kind)) : [];
+    }
+    if (saved?.version === 1) this.ignored = new Set(Array.isArray(saved.ignored) ? saved.ignored.filter((key) => typeof key === "string") : []);
+  }
+  persist() {
+    if (!this.stateFile) return Promise.resolve();
+    const saved = structuredClone({ version: 1, lastAttempt: this.lastAttempt, checkedAt: this.checkedAt, dismissed: this.dismissed, ignored: [...this.ignored], rows: this.rows.filter((r) => ["github", "npm"].includes(r.source.kind)) });
+    this.saveQueue = this.saveQueue.catch(() => {
+    }).then(() => writePrivateJson(this.stateFile, saved));
+    return this.saveQueue;
+  }
+  reminderKey(row) {
+    return JSON.stringify([row.name, row.source, row.version, row.latestVersion ?? row.latestCommit]);
+  }
+  targetKey(row) {
+    const source = row.source;
+    return JSON.stringify(source.kind === "npm" ? [row.name, "npm", source.package, source.tag, row.latestVersion] : source.kind === "github" ? [row.name, "github", source.owner, source.repo, source.ref ?? "HEAD", row.latestCommit] : [row.name, "unsupported"]);
+  }
+  isIgnored(row) {
+    return this.ignored.has(this.targetKey(row));
+  }
+  reminders() {
+    return this.rows.filter((r) => r.status === "available" && !this.isIgnored(r) && (!Object.hasOwn(this.dismissed, r.name) || this.dismissed[r.name] !== this.reminderKey(r))).map((r) => ({ key: this.reminderKey(r), targetKey: this.targetKey(r), name: r.name, version: r.version, latestVersion: r.latestVersion, latestCommit: r.latestCommit }));
+  }
+  async ignore(keys, restore = false) {
+    if (this.flight) throw Error("\u5DF2\u6709\u63D2\u4EF6\u64CD\u4F5C\u6B63\u5728\u6267\u884C\uFF0C\u8BF7\u7B49\u5F85\u5B8C\u6210");
+    if (!Array.isArray(keys) || !keys.length || keys.length > 200 || keys.some((k) => typeof k !== "string") || new Set(keys).size !== keys.length) throw Error("\u65E0\u6548\u7684\u7248\u672C\u5217\u8868");
+    const rows = keys.map((key) => this.rows.find((row) => row.target && ["available", "failed"].includes(row.status) && this.targetKey(row) === key));
+    if (rows.some((row) => !row)) throw Error("\u76EE\u6807\u7248\u672C\u5DF2\u6539\u53D8\uFF0C\u8BF7\u5237\u65B0\u6E05\u5355\u540E\u91CD\u8BD5");
+    const previous = new Set(this.ignored), dismissed = { ...this.dismissed };
+    for (const row of rows) {
+      if (restore) {
+        this.ignored.delete(this.targetKey(row));
+        delete this.dismissed[row.name];
+      } else this.ignored.add(this.targetKey(row));
+    }
+    try {
+      await this.persist();
+    } catch (error) {
+      this.ignored = previous;
+      this.dismissed = dismissed;
+      throw error;
+    }
+  }
+  async dismiss(keys) {
+    if (!Array.isArray(keys) || keys.length > 200 || keys.some((k) => typeof k !== "string")) throw Error("\u65E0\u6548\u7684\u63D0\u9192\u5217\u8868");
+    for (const row of this.reminders()) if (keys.includes(row.key)) Object.defineProperty(this.dismissed, row.name, { value: row.key, enumerable: true, configurable: true, writable: true });
+    await this.persist();
+  }
+  async tick() {
+    if (this.flight || !this.state().available) return;
+    await this.list();
+    if (this.abort.signal.aborted) return;
+    if (this.flight || this.now() >= this.lastAttempt && this.now() - this.lastAttempt < 864e5) return;
+    this.lastAttempt = this.now();
+    await this.persist();
+    if (!this.flight && !this.abort.signal.aborted) this.check();
+  }
+  state() {
+    return {
+      available: !!this.service()?.listBundles && !!this.profile()?.dir,
+      checkedAt: this.checkedAt,
+      reminders: this.reminders(),
+      autoCheckHours: 24,
+      rows: this.rows.map(({ spec, ...row }) => ({ ...row, ignored: this.isIgnored(row), targetKey: this.targetKey(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(join(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) && manifest.dependencies?.[b.name] && b.removable !== false).map((b) => {
+      const spec = manifest.dependencies?.[b.name];
+      const source = 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 === "unsupported" ? "unsupported" : "unchecked"),
+        ...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 (!parseVersion(found.version) || row.version && !parseVersion(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 || compareVersions(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(async () => {
+      this.job.finishedAt = Date.now();
+      try {
+        await this.persist();
+      } catch {
+        this.error = "\u66F4\u65B0\u68C0\u67E5\u8BB0\u5F55\u672A\u80FD\u4FDD\u5B58\uFF0C\u8BF7\u68C0\u67E5\u672C\u5730\u76EE\u5F55\u6743\u9650";
+      }
+      this.flight = void 0;
+    });
+  }
+  check() {
+    this.start("check", async (job) => {
+      this.lastAttempt = this.now();
+      await this.persist();
+      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, allowFreshVersions = []) {
+    const original = await jsonFile(join(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.removable === false || 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");
+    if (allowFreshVersions.includes(reviewedVersion(row))) await allowReviewedVersion(this.profile(), row);
+    const options = { enabled: row.enabled, requestId: this.job.id, ...registry ? { registry } : {} };
+    let result;
+    const refresh = async () => {
+      this.gitAbort = new AbortController();
+      try {
+        return await this.refreshPackage(this.service(), this.profile(), row, options, AbortSignal.any([this.abort.signal, this.gitAbort.signal]));
+      } finally {
+        this.gitAbort = void 0;
+      }
+    };
+    if (row.source.kind === "github" || row.name === this.selfName) result = await refresh();
+    else {
+      result = await outsideActivation(this.hmr(), () => this.service().installBundle(row.target, options));
+      if (result.error?.code === "already-installed") result = await refresh();
+    }
+    if (installFailed(result)) return { name: row.name, ...installFailure(result), expectedVersion: row.latestVersion };
+    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"
+      };
+    }
+    const reloadPending = result.application === "restart-required" && this.onInstalled?.(row.name) === true;
+    return { name: row.name, status: "installed", application: reloadPending ? "reload-pending" : result.application, message: reloadPending ? "\u5DF2\u5B89\u88C5\uFF0C\u7B49\u5F85\u5F53\u524D\u64CD\u4F5C\u7ED3\u675F\u540E\u81EA\u52A8\u52A0\u8F7D\uFF1B\u8FD0\u884C\u7248\u672C\u89C1\u9762\u677F\u9876\u90E8" : 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: !reloadPending && result.application === "restart-required" };
+  }
+  update(names, registry, allowFreshVersions = []) {
+    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((name2) => this.rows.find((r) => r.name === name2));
+    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");
+    const reviewed = selected.map(reviewedVersion).filter(Boolean);
+    if (!Array.isArray(allowFreshVersions) || allowFreshVersions.length > selected.length || new Set(allowFreshVersions).size !== allowFreshVersions.length || allowFreshVersions.some((v) => typeof v !== "string" || !reviewed.includes(v))) throw Error("\u786E\u8BA4\u7684\u63D2\u4EF6\u7248\u672C\u5DF2\u6539\u53D8\uFF0C\u8BF7\u91CD\u65B0\u67E5\u770B\u5E76\u786E\u8BA4\u66F4\u65B0");
+    selected.sort((a, b) => Number(a.name === this.selfName) - Number(b.name === this.selfName));
+    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, allowFreshVersions);
+        } 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();
+    });
+  }
+  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.dismiss") await this.dismiss(input.keys);
+    else if (input.action === "plugins.ignore") await this.ignore(input.keys);
+    else if (input.action === "plugins.unignore") await this.ignore(input.keys, true);
+    else if (input.action === "plugins.check") this.check();
+    else if (input.action === "plugins.update") this.update(input.names, input.registry, input.allowFreshVersions);
+    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/http.mjs
+import { randomBytes, timingSafeEqual } from "node:crypto";
+var ENDPOINT = "/.well-known/dsh-plugin-updates";
+var HttpError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+};
+var loopback = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+function localRequest(req) {
+  try {
+    const host = req.headers.host;
+    const url = new URL(`http://${host}`);
+    if (url.host !== host || !loopback.has(url.hostname)) return false;
+    const remote = req.socket?.remoteAddress;
+    return (!remote || ["127.0.0.1", "::1", "::ffff:127.0.0.1"].includes(remote)) && (!req.headers.origin || [`http://${host}`, `https://${host}`].includes(req.headers.origin)) && req.headers["sec-fetch-site"] !== "cross-site";
+  } catch {
+    return false;
+  }
+}
+function updatesHandler(updater, pluginVersion) {
+  const key = randomBytes(32).toString("base64url");
+  const state = () => ({ pluginVersion, pluginUpdates: updater.state(), key });
+  return async (req, res) => {
+    const json = (status, value) => {
+      res.writeHead(status, { "Content-Type": "application/json", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" });
+      res.end(JSON.stringify(value));
+    };
+    try {
+      if (!localRequest(req)) throw new HttpError(403, "\u4EC5\u5141\u8BB8\u672C\u673A\u540C\u6E90\u8BF7\u6C42");
+      if (req.method === "GET") {
+        json(200, state());
+        return;
+      }
+      if (req.method !== "POST") throw new HttpError(405, "\u65B9\u6CD5\u65E0\u6548");
+      const actual = Buffer.from(req.headers["x-plugin-updates-key"] ?? ""), expected = Buffer.from(key);
+      if (actual.length !== expected.length || !timingSafeEqual(actual, expected)) throw new HttpError(401, "\u8BF7\u5237\u65B0\u66F4\u65B0\u7BA1\u7406\u9875\u9762");
+      if (!/^application\/json(?:\s*;|$)/i.test(req.headers["content-type"] ?? "")) throw new HttpError(415, "\u9700\u8981 JSON");
+      let size = 0;
+      const chunks = [];
+      for await (const chunk of req) {
+        size += chunk.length;
+        if (size > 65536) throw new HttpError(413, "\u8BF7\u6C42\u8FC7\u5927");
+        chunks.push(Buffer.from(chunk));
+      }
+      let input;
+      try {
+        input = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+      } catch {
+        throw new HttpError(400, "JSON \u65E0\u6548");
+      }
+      if (!input || typeof input !== "object" || Array.isArray(input)) throw new HttpError(400, "\u64CD\u4F5C\u65E0\u6548");
+      try {
+        await updater.action(input);
+      } catch {
+        throw new HttpError(400, "\u64CD\u4F5C\u672A\u6267\u884C\uFF0C\u8BF7\u5237\u65B0\u6E05\u5355\u5E76\u91CD\u65B0\u68C0\u67E5\uFF1B\u4EC5\u652F\u6301\u5DF2\u5B89\u88C5\u63D2\u4EF6\u7684\u68C0\u67E5\u3001\u66F4\u65B0\u3001\u63D0\u9192\u548C\u53D6\u6D88\u64CD\u4F5C");
+      }
+      json(200, state());
+    } catch (error) {
+      json(error instanceof HttpError ? error.status : 500, { error: error instanceof HttpError ? error.message : "\u66F4\u65B0\u7BA1\u7406\u6682\u4E0D\u53EF\u7528\uFF0C\u8BF7\u68C0\u67E5 DSH \u63D2\u4EF6\u9875" });
+    }
+  };
+}
+
+// package.json
+var version = "0.1.1";
+
+// src/index.mjs
+var name = "@androidsup/dsh-plugin-updates";
+var inject = ["pluginManager", "profileContext"];
+async function apply(ctx) {
+  const updater = new PluginUpdates({
+    service: () => ctx.pluginManager,
+    profile: () => ctx.profileContext,
+    hmr: () => ctx.get("hmr"),
+    stateFile: join2(ctx.profileContext.dir, ".dsh-plugin-updates", "state.json")
+  });
+  let closed = false, timer;
+  ctx.effect(() => () => {
+    closed = true;
+    clearInterval(timer);
+    updater.abort.abort();
+    return Promise.allSettled([updater.flight, updater.saveQueue]);
+  });
+  await updater.load();
+  if (closed) return;
+  ctx.inject(["webServer"], (webCtx) => {
+    webCtx.effect(() => webCtx.webServer.register({ kind: "exact", path: ENDPOINT, handler: updatesHandler(updater, version) }));
+  });
+  const tick = () => {
+    void updater.tick().catch(() => ctx.logger.warn("plugin-updates: automatic check unavailable"));
+  };
+  tick();
+  timer = setInterval(tick, 6e4);
+  timer.unref();
+}
+export {
+  apply,
+  inject,
+  name
+};
+//# sourceMappingURL=index.js.map