@chendaleiq/dsh-plugin-auto-update 0.0.0-stage → 0.1.16

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 chendaleiQ
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.en.md

@@ -0,0 +1,76 @@
+# dsh-plugin-auto-update
+
+Automatic, per-package updates for the DSH plugins you choose: switch it on in the
+plugin page and tick the plugins that may upgrade themselves.
+
+## What it does
+
+- Looks up the **newest published version** of installed plugin bundles on npm
+- Only touches packages you ticked; local `link:` / `file:` installs, pinned
+  versions and bundles with a manager error are skipped
+- Never jumps a **major** version and never installs a **prerelease** by default
+- Updates go through the profile's running `pluginManager` — profile write lock,
+  pnpm run, bundle-patch check and HMR reload stay with it. A failed install
+  **reinstalls the previous version**
+
+## Install
+
+Plugins → Install → paste the package name:
+
+```
+@chendaleiq/dsh-plugin-auto-update
+```
+
+Restart DSH afterwards: a host half only loads on a fresh generation. The GitHub
+address and an absolute local directory work the same way.
+
+## Settings: a panel on the plugin's page
+
+Plugins → **DSH Plugin Auto Update**, at the bottom of the detail page:
+
+- **Enable auto update** — the master switch, off by default
+- **Version policy** — allow a new major, allow prereleases
+- **Plugins that may update** — every registry-installed bundle, each with a
+  checkbox; the first row means "all of them"
+- A bundle that cannot update is greyed out with its reason (local install,
+  pinned, or has an error)
+
+Edits apply immediately; no restart.
+
+## Language
+
+The copy follows DSH's language setting: Chinese by default, English once the app
+is switched.
+
+## Log
+
+`~/.dsh/plugin-auto-update.log`, one JSON object per line (`schedule`, `cycle`,
+`notify`, `plugin-started`; actions `current`, `would-update`, `updated`,
+`failed`, `error`).
+
+## Deliberate limits
+
+- Only registry-installed bundles whose dependency is a range (`^`, `~`, `*`,
+  `latest`); `link:` / `file:` and exact pins are never touched
+- Bundles shipped with the app are never touched; your other configuration stays
+  as it is
+- Registry or manager failures are logged and never interrupt the other packages
+- A host half needs an app restart; a renderer half is swapped by HMR
+
+## Advanced
+
+Fields the panel leaves out (`intervalHours`, six hours by default,
+`initialDelayMinutes`, `maxUpdatesPerRun`, `dryRun`, `registry`, `timeoutMs`,
+`notify`, `logPath`) live in this bundle's `config` in the profile patch, or as an
+override in `~/.dsh/profiles/<profile>/cordis.patch.yml`. Those need a restart.
+
+## Development
+
+```bash
+node test/index.test.mjs    # the host half's update cycle
+node test/client.test.mjs   # the renderer half: slot, remote envelope, labels
+```
+
+## License
+
+MIT · https://github.com/chendaleiQ/dsh-plugin-auto-update

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
+# dsh-plugin-auto-update
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+给 DSH 插件做**按包白名单的自动更新**：在插件页打开开关、勾选允许自动升级的插件即可。
+
+## 它做什么
+
+- 按计划去 npm 查已安装插件的**最新版本**
+- 只更新你勾选的包；本地 `link:` / `file:` 安装、锁定版本、报错的包一律跳过
+- 默认**不跨大版本**、**不装预发布**
+- 更新走 profile 里运行中的官方 `pluginManager`：profile 写锁、pnpm 执行、bundle 补丁校验、HMR 重载都由它负责；安装失败会把**旧版本装回去**
+
+## 安装
+
+插件页 → 安装 → 填包名：
+
+```
+@chendaleiq/dsh-plugin-auto-update
+```
+
+装完**重启 DSH**（宿主半边需要新代际才加载）。也可以填 GitHub 地址或本地目录的绝对路径。
+
+## 配置：插件页里的面板
+
+插件 → **DSH 插件自动更新** → 详情页底部：
+
+- **启用自动更新** —— 总开关，默认关
+- **升级范围** —— 允许跨大版本 / 允许预发布
+- **自动更新的插件** —— 列出所有从注册表安装的插件，逐个勾选；「全部可更新的插件」= 通配
+- 不能更新的包会置灰并说明原因（本地安装 / 锁定版本 / 存在错误）
+
+改动即时生效，不需要重启。
+
+## 语言
+
+跟随 DSH 的语言设置：默认中文，切英文后插件页和面板文案同步变英文。
+
+## 日志
+
+`~/.dsh/plugin-auto-update.log`，每行一个 JSON：
+
+```json
+{"at":"…","kind":"cycle","decisions":[{"name":"dsh-plugin-desktop-notify","action":"updated","installed":"0.5.6","latest":"0.5.7"}]}
+```
+
+`action` 有 `current` / `would-update` / `updated` / `failed` / `error`。
+
+## 边界（有意为之）
+
+- 只碰「从注册表安装、且依赖写成范围（`^` `~` `*` `latest`）」的包
+- 随 DSH 自带的 bundle 不动；不修改你的其它配置
+- 网络或插件管理器出错只记录，不中断其它包
+- 宿主半边更新后需要重启应用；渲染层由 HMR 直接换掉
+
+## 高级配置
+
+面板没覆盖的字段（`intervalHours` 默认 6 小时、`initialDelayMinutes`、`maxUpdatesPerRun`、`dryRun`、`registry`、`timeoutMs`、`notify`、`logPath`）写在 profile patch 的 `config` 里，或覆盖 `~/.dsh/profiles/<profile>/cordis.patch.yml` 的同一行。改完需要重启。
+
+## 开发
+
+```bash
+node test/index.test.mjs    # 宿主半边：检查与更新循环
+node test/client.test.mjs   # 渲染层：插槽注册、远端信封、置灰原因
+```
+
+## 协议
+
+MIT · 仓库 https://github.com/chendaleiQ/dsh-plugin-auto-update

package/cordis.patch.yml

@@ -0,0 +1,25 @@
+# The dsh-plugin-auto-update bundle patch.
+#
+# Host half (`index.js`) runs the update cycle through the profile's own
+# pluginManager service. Browser half (`lib/client.js`) puts a panel on this
+# bundle's page in the Plugins tab; that panel writes the volatile fields below
+# through the settings service, so edits apply without a restart.
+- insert:
+    - id: auto-update
+      name: '@chendaleiq/dsh-plugin-auto-update'
+      config:
+        # Nothing is updated until this is switched on in the panel.
+        enabled: false
+        # ["*"] = every registry-installed bundle; or name the packages.
+        packages:
+          - '*'
+        allowMajor: false
+        allowPrerelease: false
+        dryRun: false
+        intervalHours: 6
+        initialDelayMinutes: 1
+        maxUpdatesPerRun: 5
+        registry: 'https://registry.npmjs.org'
+        timeoutMs: 20000
+        notify: true
+        logPath: '~/.dsh/plugin-auto-update.log'

package/icon.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="Plugin auto update">
+  <rect width="64" height="64" rx="14" fill="#4D6BFE"/>
+  <g fill="none" stroke="#fff" stroke-width="3.6" stroke-linecap="round" stroke-linejoin="round">
+    <path d="M18.5 31a13.5 13.5 0 0 1 22.6-9.1"/>
+    <path d="M44.5 15.6v7.2h-7.2"/>
+    <path d="M45.5 33a13.5 13.5 0 0 1-22.6 9.1"/>
+    <path d="M19.5 48.4v-7.2h7.2"/>
+  </g>
+</svg>

package/index.js

@@ -0,0 +1,174 @@
+/**
+ * dsh-plugin-auto-update — host half.
+ *
+ * Settings live in the profile Cordis patch as volatile fields, so the page this
+ * bundle registers in the Plugins tab can edit them live. The update cycle
+ * itself lives in `./lib/plan.js`, which stays testable without the app.
+ */
+
+import z from "@deepseek-ai/schemastery"
+
+import { DEFAULTS, createUpdater, resolveSettings } from "./lib/plan.js"
+
+export * from "./lib/plan.js"
+
+/** Settings namespace: the profile entry id this plugin's row is addressed by. */
+const NAMESPACE = "auto-update"
+
+/** Settings the plugin page edits; every field is volatile, so edits apply live. */
+export const Config = z.object({
+  enabled: z.boolean().default(false).volatile(),
+  packages: z.array(z.string()).default(["*"]).volatile(),
+  allowMajor: z.boolean().default(false).volatile(),
+  allowPrerelease: z.boolean().default(false).volatile(),
+  dryRun: z.boolean().default(false).volatile(),
+  intervalHours: z.number().default(6).volatile(),
+  initialDelayMinutes: z.number().default(1).volatile(),
+  maxUpdatesPerRun: z.number().default(5).volatile(),
+  registry: z.string().default("https://registry.npmjs.org").volatile(),
+  timeoutMs: z.number().default(20000).volatile(),
+  notify: z.boolean().default(true).volatile(),
+  logPath: z.string().default("~/.dsh/plugin-auto-update.log").volatile(),
+})
+
+/**
+ * Mount the plugin into a profile.
+ *
+ * The page in the Plugins tab writes the same fields this half reads, through
+ * the settings service: every field is volatile, so an edit is committed into
+ * the running config object without remounting this plugin.
+ *
+ * @param {object} ctx Cordis context of the host.
+ * @param {object} rawConfig Bundle config from cordis.patch.yml.
+ */
+export function apply(ctx, rawConfig) {
+  /** The live config object the loader keeps updated in place. */
+  const live = () => ctx.fiber?.config ?? ctx.config ?? rawConfig ?? {}
+  /**
+   * A volatile field is a reference the loader keeps current (`{ get(), [write] }`,
+   * frozen, carrying a symbol), not the value itself; read through it so a
+   * settings-page edit is visible here at once. Detected structurally rather
+   * than through cosmokit: a link-installed plugin may only import the packages
+   * the runtime actually ships, and cosmokit is not one of them.
+   */
+  const isVolatileRef = (value) => typeof value === "object"
+    && value !== null
+    && typeof value.get === "function"
+    && Object.getOwnPropertySymbols(value).length > 0
+  const pluck = (config, key) => {
+    const value = config?.[key]
+    return isVolatileRef(value) ? value.get() : value
+  }
+  /**
+   * The settings document is the source of truth: it merges the bundle defaults
+   * with the profile override the page writes, while the config object this
+   * plugin was mounted with can still be the bundle layer alone.
+   */
+  const settingsFromDocument = () => {
+    try {
+      const forms = ctx.get?.("settings")
+      const row = forms?.describe?.().find?.((item) => item.ns === NAMESPACE)
+      if (row === undefined) return undefined
+      return resolveSettings(row.value ?? {})
+    } catch {
+      return undefined
+    }
+  }
+  const settingsOf = () => settingsFromDocument() ?? resolveSettings(
+    Object.fromEntries(Object.keys(DEFAULTS).map((key) => [key, pluck(live(), key)])),
+  )
+
+  const updater = createUpdater({
+    readSettings: settingsOf,
+    logPath: settingsOf().logPath,
+    manager: () => {
+      try {
+        return ctx.get?.("pluginManager")
+      } catch {
+        return undefined
+      }
+    },
+  })
+
+  // The page is ours; keep the settings service from generating one.
+  ctx.inject(["settings"], (child) => {
+    child.effect(() => child.settings.configure({ auto: false }, ctx.fiber), "auto-update: settings presentation")
+  })
+
+  /**
+   * One timeout drives everything: when it fires the settings are read again,
+   * so switching the feature on takes effect without a restart (a disabled
+   * plugin wakes up once a minute to look).
+   */
+  let timer
+  let stopped = false
+  const POLL_MS = 60_000
+  const arm = (delayMs) => {
+    if (stopped) return
+    timer = setTimeout(fire, Math.max(1000, delayMs))
+    timer.unref?.()
+  }
+  const fire = async () => {
+    if (stopped) return
+    let enabled = false
+    let intervalMs = DEFAULTS.intervalHours * 3_600_000
+    try {
+      const settings = settingsOf()
+      enabled = settings.enabled === true
+      intervalMs = Math.max(0.05, settings.intervalHours) * 3_600_000
+      if (enabled) await updater.runOnce()
+    } catch (error) {
+      await updater.log({ kind: "cycle", error: String(error?.message ?? error) })
+    }
+    arm(enabled ? intervalMs : POLL_MS)
+  }
+  const schedule = async () => {
+    const settings = settingsOf()
+    await updater.log({
+      kind: "schedule",
+      enabled: settings.enabled === true,
+      firstCheckMinutes: settings.initialDelayMinutes,
+      intervalHours: settings.intervalHours,
+    })
+    arm(Math.max(0, settings.initialDelayMinutes) * 60_000)
+  }
+
+  ctx.effect(() => {
+    void schedule()
+    return () => {
+      stopped = true
+      clearTimeout(timer)
+    }
+  }, "auto-update: schedule")
+
+  // A settings edit is a deliberate "look now", and so is a management change;
+  // without these the next look would wait for the interval to pass.
+  ctx.effect(() => {
+    // The loader emits this one filtered to the edited plugin's own fiber, so it
+    // must be heard here rather than on the root.
+    const listener = () => {
+      void updater.runOnce({ force: true }).catch(() => {})
+    }
+    ctx.on?.("loader/volatile-update", listener)
+    return () => {
+      ctx.off?.("loader/volatile-update", listener)
+    }
+  }, "auto-update: settings changes")
+
+  // A management change is the natural moment to look again; the next tick
+  // would otherwise wait for the interval to pass.
+  ctx.effect(() => {
+    // The manager emits on its own context, which bubbles to the root — not to
+    // a sibling row. Listen on the root so a management change is noticed.
+    const host = ctx.root ?? ctx
+    const listener = () => {
+      void updater.runOnce({ force: true }).catch(() => {})
+    }
+    host.on?.("plugin-manager/changed", listener)
+    return () => {
+      host.off?.("plugin-manager/changed", listener)
+    }
+  }, "auto-update: manager changes")
+
+  void updater.log({ kind: "plugin-started", pid: process.pid, platform: process.platform })
+}

package/lib/client.js

@@ -0,0 +1,410 @@
+/**
+ * dsh-plugin-auto-update — browser half.
+ *
+ * Registers one section on this bundle's page in the Plugins tab: a switch that
+ * turns automatic updates on, and checkbox lists for what may update and how
+ * far. Everything it shows and writes goes through the settings service
+ * (`configForms`), which persists the change in the profile Cordis patch and
+ * applies it to the running host plugin; the installed-bundle list comes from
+ * the plugin manager's own remote namespace.
+ */
+
+window.__ModuleLoader__.load({
+  id: "@chendaleiq/dsh-plugin-auto-update",
+  factory: (require) => {
+    const React = require("react")
+    const { jsx, jsxs } = require("react/jsx-runtime")
+    const primitives = require("@deepseek-ai/dsh-client-ui-primitives")
+
+    /** Dictionary namespace for this page. */
+    const NS = "auto-update"
+    /** Settings namespace: the host row id this plugin's patch inserts. */
+    const NAMESPACE = "auto-update"
+    /** Package this section belongs to; other subjects render nothing. */
+    const BUNDLE = "@chendaleiq/dsh-plugin-auto-update"
+    /** Required services. */
+    const inject = ["slots", "locale", "configForms", "remote", "remote.pluginManager", "remote.settings"]
+
+    const CSS_ID = "dsh-plugin-auto-update/section.css"
+    const CSS = `
+.dshAutoUpdate{display:flex;flex-direction:column;gap:10px}
+.dshAutoUpdateTitle{margin:0;font-size:14px;font-weight:500;line-height:20px;color:var(--dsw-alias-label-primary)}
+.dshAutoUpdateHint{margin:0;font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary)}
+.dshAutoUpdateRow{display:flex;align-items:center;justify-content:space-between;gap:16px}
+.dshAutoUpdateLabel{font-size:13px;line-height:20px;color:var(--dsw-alias-label-primary)}
+.dshAutoUpdateSub{font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary)}
+.dshAutoUpdateGroup{display:flex;flex-direction:column;gap:8px;border:.5px solid var(--dsw-alias-border-l2);border-radius:var(--dsw-radius-lg);padding:9px 12px}
+.dshAutoUpdateGroupTitle{margin:0;font-size:12px;font-weight:500;line-height:18px;color:var(--dsw-alias-label-secondary)}
+.dshAutoUpdateList{display:flex;flex-direction:column;gap:6px;margin:0;padding:0;list-style:none}
+.dshAutoUpdatePolicies{display:flex;flex-wrap:wrap;gap:6px 18px;margin:0;padding:0;list-style:none}
+.dshAutoUpdateItem{display:flex;align-items:center;gap:8px;font-size:13px;line-height:20px;color:var(--dsw-alias-label-primary)}
+.dshAutoUpdateItem input{accent-color:var(--dsw-alias-brand-primary);width:14px;height:14px;margin:0;flex:none}
+.dshAutoUpdateName{font-family:var(--dsw-font-mono,ui-monospace,SFMono-Regular,Menlo,monospace);font-size:12px;overflow-wrap:anywhere}
+.dshAutoUpdateVersion{color:var(--dsw-alias-label-tertiary);font-size:12px;margin-left:auto;flex:none}
+.dshAutoUpdateEmpty{margin:0;font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary)}
+
+`
+
+    /** Dictionaries registered with the app's own locale service. */
+    const DICTS = {
+      zh: {
+        title: "插件自动更新",
+        intro: "让选中的插件自动保持最新版本。更新由插件管理器完成，失败会回滚到原版本。",
+        enabled: "启用自动更新",
+        enabledHint: "关闭时插件什么都不做",
+        packages: "自动更新的插件",
+        all: "全部可更新的插件",
+        emptyAll: "还没有从注册表安装的插件。",
+        emptyNone: "已安装的插件都是本地安装或锁定版本，不参与自动更新。",
+        reasonLocal: "本地安装",
+        reasonPinned: "锁定版本",
+        reasonError: "存在错误",
+        summary: "共 {n} 个插件 · {m} 个可自动更新",
+        writeFailed: "保存失败：{reason}",
+        listFailed: "读取已安装插件列表失败，请刷新后重试。",
+        loading: "读取中…",
+        policies: "升级范围",
+        allowMajor: "允许跨大版本",
+        allowPrerelease: "允许预发布版本（rc / beta）",
+        dryRun: "仅演练（只写日志，不安装）",
+        readOnly: "本部署的设置为只读。",
+        unavailable: "设置服务还没有提供这个插件的配置，请重启后再试。",
+        stateLine: "设置状态：{status}",
+      },
+      en: {
+        title: "Auto update",
+        intro: "Keep the selected plugins on their newest release. Updates run through the plugin manager; a failed install rolls back.",
+        enabled: "Enable auto update",
+        enabledHint: "Nothing happens while this is off",
+        packages: "Plugins that may update",
+        all: "Every updatable plugin",
+        emptyAll: "No plugin has been installed from a registry yet.",
+        emptyNone: "Every installed plugin is local or pinned, so none can update.",
+        reasonLocal: "local install",
+        reasonPinned: "pinned",
+        reasonError: "has an error",
+        summary: "{n} installed · {m} updatable",
+        writeFailed: "Save failed: {reason}",
+        listFailed: "Could not read the installed plugins; refresh and try again.",
+        loading: "Loading…",
+        policies: "Version policy",
+        allowMajor: "Allow a new major version",
+        allowPrerelease: "Allow prereleases (rc / beta)",
+        dryRun: "Dry run (log only, install nothing)",
+        readOnly: "Settings are read-only on this deployment.",
+        unavailable: "The settings service does not serve this plugin's configuration yet; restart and try again.",
+        stateLine: "Settings state: {status}",
+      },
+    }
+
+    /** A dependency value that names a mutable range rather than a pin or a path. */
+    function isFloatingSpec(spec) {
+      const text = String(spec ?? "").trim()
+      if (text === "") return false
+      if (/^(link|file|workspace|portal|git|github|https?):/.test(text)) return false
+      if (/^\.{1,2}\//.test(text) || text.startsWith("/") || text.startsWith("~/")) return false
+      if (/^(npm|jsr):/.test(text)) return true
+      return !/^=?v?\d+\.\d+\.\d+([-+][0-9A-Za-z.-]+)?$/.test(text)
+    }
+
+    /** Why a bundle cannot take part, or null when it can. */
+    function blockReason(bundle) {
+      if (bundle.error !== undefined) return "error"
+      const source = String(bundle.source ?? "")
+      if (/^(link|file|workspace|portal)/.test(source)) return "local"
+      if (!isFloatingSpec(source)) return "pinned"
+      return null
+    }
+
+    /**
+     * Every bundle the profile installs, each with the reason it cannot update
+     * (null when it can). Local and pinned installs stay visible, so the list
+     * explains itself instead of looking empty.
+     */
+    function installedBundles(bundles) {
+      return (Array.isArray(bundles) ? bundles : []).filter((bundle) => {
+        if (bundle === null || typeof bundle !== "object") return false
+        if (bundle.availability !== "profile") return false
+        if (bundle.installed !== true) return false
+        return typeof bundle.name === "string" && typeof bundle.version === "string"
+      }).map((bundle) => ({ ...bundle, blocked: blockReason(bundle) }))
+        .sort((left, right) => left.name.localeCompare(right.name))
+    }
+
+    /**
+     * Read one remote answer: this deployment answers `{ ok, value }`, and a
+     * refusal carries `{ ok: false, error }`. Anything else is a bug worth
+     * surfacing rather than an empty list.
+     */
+    function listFromResponse(response) {
+      if (response?.ok !== true) {
+        const reason = response?.error?.message ?? response?.error?.code ?? "refused"
+        throw new Error(String(reason))
+      }
+      return Array.isArray(response.value) ? response.value : []
+    }
+
+    /** Install the section's stylesheet once per document. */
+    function installStyles() {
+      if (typeof document === "undefined") return () => {}
+      const existing = document.querySelector(`style[data-plugin-css=${JSON.stringify(CSS_ID)}]`)
+      if (existing !== null) return () => {}
+      const tag = document.createElement("style")
+      tag.dataset.plugin = BUNDLE
+      tag.dataset.pluginCss = CSS_ID
+      tag.textContent = CSS
+      document.head.appendChild(tag)
+      return () => tag.remove()
+    }
+
+    /**
+     * Mount the plugin page section.
+     * @param ctx - the browser plugin context.
+     */
+    function apply(ctx) {
+      const css = installStyles()
+      ctx.effect(() => css, "auto-update: section styles")
+
+      // The app's locale service owns the language; registering here keeps the
+      // section in step with Settings → General rather than the window language.
+      ctx.effect(() => ctx.locale.register(NS, DICTS), "auto-update: dictionaries")
+      const t = ctx.locale.bind(NS)
+
+      const form = ctx.configForms.get(NAMESPACE)
+
+      /** Re-render when the active language — or a late dictionary — changes. */
+      const useLocale = () => React.useSyncExternalStore(
+        (listener) => ctx.locale.subscribe(listener),
+        () => ctx.locale.getSnapshot().revision,
+      )
+
+      const useForm = () => React.useSyncExternalStore(
+        (listener) => form.subscribe(listener),
+        () => form.getSnapshot(),
+      )
+
+      /** The shared settings document: holds the revision a write needs. */
+      const mirror = ctx.configForms.describe?.()
+
+      /** The updatable bundles, read once per mount from the manager's remote. */
+      const useUpdatableBundles = () => {
+        const [state, setState] = React.useState({ status: "loading", bundles: [] })
+        React.useEffect(() => {
+          let alive = true
+          const read = () => {
+            Promise.resolve()
+              .then(() => ctx.remote.pluginManager.listBundles())
+              .then((response) => {
+                if (alive) setState({ status: "ready", bundles: installedBundles(listFromResponse(response)) })
+              })
+              .catch((error) => {
+                if (alive) setState({ status: "failed", bundles: [], error: String(error?.message ?? error) })
+              })
+          }
+          read()
+          return () => {
+            alive = false
+          }
+        }, [])
+        return state
+      }
+
+      /** One section on this bundle's page; other subjects get nothing. */
+      function AutoUpdateSection({ subject }) {
+        const snapshot = useForm()
+        const [write, setWrite] = React.useState(null)
+        const bundles = useUpdatableBundles()
+        useLocale()
+        if (subject === undefined || subject === null || subject.kind !== "bundle") return null
+        if (subject.pkg?.name !== BUNDLE) return null
+
+        const updatable = bundles.bundles.filter((bundle) => bundle.blocked === null)
+        const value = snapshot?.value ?? {}
+        const writable = snapshot?.writable !== false
+        const unavailable = snapshot?.status === "unavailable"
+        const enabled = value.enabled === true
+        const packages = Array.isArray(value.packages) ? value.packages : ["*"]
+        const everything = packages.includes("*")
+        const selected = (name) => everything || packages.includes(name)
+        /** The namespace's revision in the shared document, or undefined while it is unread. */
+        const revisionOf = () => {
+          const view = mirror?.getSnapshot?.()?.view
+          return view?.namespaces?.find((row) => row.ns === NAMESPACE)?.revision
+        }
+
+        /**
+         * Write one field through the settings remote, retrying once after a
+         * refresh: a stale revision is the common failure, and the reason the
+         * remote gives is worth showing instead of a bare "refused".
+         */
+        const persist = async (field, value) => {
+          let lastError
+          const ops = [{ op: "set", path: [field], value }]
+          for (let attempt = 0; attempt < 2; attempt += 1) {
+            const response = await ctx.remote.settings.mutate(NAMESPACE, ops, attempt === 0 ? revisionOf() : await freshRevision())
+            if (response?.ok === true) {
+              mirror?.acceptView?.(response.value)
+              return { ok: true }
+            }
+            if (response?.error !== undefined) lastError = response.error
+            if (attempt === 0) await mirror?.load?.()
+          }
+          const code = lastError?.code ?? lastError?.message ?? "refused"
+          return { ok: false, reason: String(code) }
+        }
+
+        /** Reload the document and read this namespace's revision again. */
+        const freshRevision = async () => {
+          await mirror?.load?.()
+          return revisionOf()
+        }
+
+        const set = (field, next) => {
+          if (!writable) {
+            setWrite({ ok: false, reason: "read-only" })
+            return
+          }
+          Promise.resolve()
+            .then(() => persist(field, next))
+            .then((result) => setWrite(result))
+            .catch((error) => setWrite({ ok: false, reason: String(error?.message ?? error) }))
+        }
+        const writePackages = (names) => set("packages", names)
+
+        /** Checking "all" stores the wildcard; unchecking stores an empty allowlist. */
+        const onAll = (checked) => writePackages(checked ? ["*"] : [])
+        /** A single toggle keeps the explicit list when the wildcard was not in play. */
+        const onOne = (name, checked) => {
+          const base = everything ? updatable.map((item) => item.name) : packages.filter((item) => item !== "*")
+          const next = checked ? [...new Set([...base, name])] : base.filter((item) => item !== name)
+          writePackages(next)
+        }
+
+        return jsxs("section", {
+          className: "dshAutoUpdate",
+          "data-plugin-auto-update": true,
+          children: [
+            jsx("h4", { className: "dshAutoUpdateTitle", children: t("title") }),
+            unavailable ? jsx("p", { className: "dshAutoUpdateHint", children: t("unavailable") }) : null,
+            !writable ? jsx("p", { className: "dshAutoUpdateHint", children: t("readOnly") }) : null,
+            write === null || write.ok !== false
+              ? null
+              : jsx("p", {
+                  className: "dshAutoUpdateEmpty",
+                  "data-auto-update-write": "failed",
+                  children: t("writeFailed", { reason: String(write.reason) }),
+                }),
+            jsx("div", { className: "dshAutoUpdateRow", children: [
+              jsxs("div", { children: [
+                jsx("div", { className: "dshAutoUpdateLabel", children: t("enabled") }),
+                jsx("div", { className: "dshAutoUpdateSub", children: t("enabledHint") }),
+              ] }),
+              jsx(primitives.Switch, {
+                checked: enabled,
+                label: t("enabled"),
+                disabled: !writable || unavailable,
+                onChange: (next) => set("enabled", next === true),
+              }),
+            ] }),
+            jsxs("div", { className: "dshAutoUpdateGroup", children: [
+              jsx("h5", { className: "dshAutoUpdateGroupTitle", children: t("policies") }),
+              jsx("ul", { className: "dshAutoUpdatePolicies", children: ["allowMajor", "allowPrerelease"].map((field) => jsx("li", { className: "dshAutoUpdateItem", children: [
+                jsx("input", {
+                  type: "checkbox",
+                  id: `dsh-auto-update-${field}`,
+                  checked: value[field] === true,
+                  disabled: !writable,
+                  onChange: (event) => set(field, event.target.checked === true),
+                }),
+                jsx("label", { htmlFor: `dsh-auto-update-${field}`, children: t(field) }),
+              ] }, field)) }),
+            ] }),
+            enabled
+              ? jsxs("div", { className: "dshAutoUpdateGroup", children: [
+                  jsxs("div", { className: "dshAutoUpdateRow", children: [
+                    jsx("h5", { className: "dshAutoUpdateGroupTitle", children: t("packages") }),
+                    jsx("span", { className: "dshAutoUpdateSub", "data-auto-update-count": `${bundles.bundles.length}/${updatable.length}`, children: bundles.status === "ready" ? t("summary", { n: bundles.bundles.length, m: updatable.length }) : "" }),
+                  ] }),
+                  bundles.status === "failed"
+                    ? jsx("p", { className: "dshAutoUpdateEmpty", children: `${t("listFailed")} ${bundles.error ?? ""}`.trim() })
+                    : null,
+                  bundles.status === "ready" && bundles.bundles.length === 0
+                    ? jsx("p", { className: "dshAutoUpdateEmpty", children: t("emptyAll") })
+                    : null,
+                  bundles.status === "ready" && bundles.bundles.length > 0 && updatable.length === 0
+                    ? jsx("p", { className: "dshAutoUpdateEmpty", children: t("emptyNone") })
+                    : null,
+                  bundles.status === "ready" && bundles.bundles.length > 0
+                    ? jsxs("ul", { className: "dshAutoUpdateList", children: [
+                        updatable.length === 0
+                          ? null
+                          : jsx("li", { className: "dshAutoUpdateItem", children: [
+                              jsx("input", {
+                                type: "checkbox",
+                                id: "dsh-auto-update-all",
+                                checked: everything,
+                                disabled: !writable,
+                                onChange: (event) => onAll(event.target.checked === true),
+                              }),
+                              jsx("label", { htmlFor: "dsh-auto-update-all", children: t("all") }),
+                            ] }),
+                        ...bundles.bundles.map((bundle) => {
+                          const id = `dsh-auto-update-${bundle.name}`
+                          const reason = bundle.blocked === null
+                            ? null
+                            : bundle.blocked === "local"
+                              ? t("reasonLocal")
+                              : bundle.blocked === "pinned"
+                                ? t("reasonPinned")
+                                : t("reasonError")
+                          return jsxs("li", { className: "dshAutoUpdateItem", children: [
+                            jsx("input", {
+                              type: "checkbox",
+                              id,
+                              checked: bundle.blocked === null && selected(bundle.name),
+                              disabled: !writable || bundle.blocked !== null,
+                              onChange: (event) => onOne(bundle.name, event.target.checked === true),
+                            }),
+                            jsx("label", { htmlFor: id, className: "dshAutoUpdateName", children: bundle.name }),
+                            jsx("span", { className: "dshAutoUpdateVersion", children: reason === null ? bundle.version : `${bundle.version} · ${reason}` }),
+                          ] })
+                        }),
+                      ] })
+                    : null,
+                ] })
+              : null,
+          ],
+        })
+      }
+
+      ctx.effect(() => ctx.slots.inject("plugins.detail.section", () => ctx.slots.register({
+        name: "plugins.detail.section",
+        id: "auto-update",
+        order: 40,
+      }, AutoUpdateSection)), "auto-update: plugin page section")
+
+      // Console handle for support: `__DSH_AUTO_UPDATE__.state()` says whether
+      // the settings document is loaded and what this plugin's namespace holds.
+      try {
+        window.__DSH_AUTO_UPDATE__ = {
+          version: "0.1.16",
+          namespace: NAMESPACE,
+          state: () => ({
+            form: form.getSnapshot(),
+            document: mirror?.getSnapshot?.(),
+          }),
+          set: (field, value) => form.set(field, value),
+          retry: () => mirror?.load?.(),
+        }
+      } catch {
+        /* a frozen window simply has no console handle */
+      }
+
+      ctx.effect(() => () => {
+        form.dispose?.()
+      }, "auto-update: form disposal")
+    }
+
+    return { inject, apply, internals: { installedBundles, listFromResponse, isFloatingSpec, blockReason } }
+  },
+})

package/lib/plan.js

@@ -0,0 +1,386 @@
+/**
+ * dsh-plugin-auto-update
+ *
+ * Host half only: keep selected plugin bundles on their newest compatible
+ * release, without going through "uninstall, reinstall, done by hand".
+ *
+ * Design notes
+ *
+ * - Updates go through the running profile's own `pluginManager` service
+ *   (`listBundles` / `removeBundle` / `installBundle`). That service owns the
+ *   profile write lock, the pnpm run, the bundle-patch check and the HMR
+ *   recompose, so this plugin never touches `package.json` or `node_modules`
+ *   itself. If the service is missing (a headless profile), the plugin does
+ *   nothing at all.
+ * - Nothing is updated unless the user switched it on AND named the package:
+ *   `packages: ["*"]` means every registry-installed bundle, an explicit list
+ *   means exactly those. Local `link:` / `file:` installs are never touched.
+ * - Pinned installs stay pinned. A dependency recorded as an exact version
+ *   (`"1.2.3"`) is left alone, because the person who wrote it chose a pin; a
+ *   range (`^1.2.3`, `~1.2.3`, `*`) is what this plugin advances.
+ * - The settings file is re-read on every cycle, so editing
+ *   `~/.dsh/plugin-auto-update.json` takes effect without a restart.
+ * - Replacing a host half needs a restart to take effect; the cycle reports
+ *   `restartRequired` and the desktop decides when to run it. A renderer half
+ *   is picked up by HMR on its own.
+ */
+
+import { execFile } from "node:child_process"
+import { appendFile, mkdir } from "node:fs/promises"
+import { homedir } from "node:os"
+import { dirname, join } from "node:path"
+
+/** Defaults written to the settings file the first time the plugin runs. */
+export const DEFAULTS = {
+  /** Master switch. Off until the person turns it on. */
+  enabled: false,
+  /** `["*"]` = every registry-installed bundle; otherwise an allowlist of package names. */
+  packages: ["*"],
+  /** A newer major is offered only when this is true. */
+  allowMajor: false,
+  /** `1.0.0-rc.1` is offered only when this is true. */
+  allowPrerelease: false,
+  /** How often to look, in hours. */
+  intervalHours: 6,
+  /** First look after this many minutes, so startup is not disturbed. */
+  initialDelayMinutes: 1,
+  /** Log what would happen without changing anything. */
+  dryRun: false,
+  /** Stop after this many updates in one cycle. */
+  maxUpdatesPerRun: 5,
+  /** Registry used to look up the newest version. */
+  registry: "https://registry.npmjs.org",
+  /** Per-request timeout for the registry lookup. */
+  timeoutMs: 20000,
+  /** A desktop banner (macOS) after a cycle that changed something. */
+  notify: true,
+  /** Where the log lives. */
+  logPath: "~/.dsh/plugin-auto-update.log",
+}
+
+const PLUGIN_LOG_LIMIT = 4000
+
+/** Expand a leading `~` against the current home. */
+export function expandHome(path) {
+  const text = String(path ?? "")
+  if (text === "~") return homedir()
+  if (text.startsWith("~/")) return join(homedir(), text.slice(2))
+  return text
+}
+
+/**
+ * Parse `X.Y.Z[-prerelease][+build]`.
+ * @returns {{major:number, minor:number, patch:number, prerelease:string}|null}
+ */
+export function parseVersion(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(
+    String(value ?? "").trim(),
+  )
+  if (match === null) return null
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ?? "",
+  }
+}
+
+/** Compare two release identifiers; numeric segments compare as numbers. */
+function comparePrerelease(left, right) {
+  if (left === right) return 0
+  if (left === "") return 1
+  if (right === "") return -1
+  const a = left.split(".")
+  const b = right.split(".")
+  for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+    const one = a[index]
+    const two = b[index]
+    if (one === undefined) return -1
+    if (two === undefined) return 1
+    const numericOne = /^\d+$/.test(one)
+    const numericTwo = /^\d+$/.test(two)
+    if (numericOne && numericTwo) {
+      const difference = Number(one) - Number(two)
+      if (difference !== 0) return difference < 0 ? -1 : 1
+      continue
+    }
+    if (numericOne !== numericTwo) return numericOne ? -1 : 1
+    if (one !== two) return one < two ? -1 : 1
+  }
+  return 0
+}
+
+/**
+ * Compare two versions the way semver orders releases.
+ * @returns {-1|0|1} negative when `left` is older.
+ */
+export function compareVersions(left, right) {
+  const a = typeof left === "string" ? parseVersion(left) : left
+  const b = typeof right === "string" ? parseVersion(right) : right
+  if (a === null || b === null) return 0
+  for (const field of ["major", "minor", "patch"]) {
+    if (a[field] !== b[field]) return a[field] < b[field] ? -1 : 1
+  }
+  return comparePrerelease(a.prerelease, b.prerelease)
+}
+
+/**
+ * Whether `latest` is an update this configuration accepts for `installed`.
+ * @param {string} installed Version currently on disk.
+ * @param {string} latest Version offered by the registry.
+ * @param {{allowMajor?:boolean, allowPrerelease?:boolean}} policy
+ */
+export function acceptsUpdate(installed, latest, policy = {}) {
+  const current = parseVersion(installed)
+  const next = parseVersion(latest)
+  if (current === null || next === null) return false
+  if (compareVersions(current, next) >= 0) return false
+  if (next.prerelease !== "" && policy.allowPrerelease !== true) return false
+  if (current.prerelease === "" && next.major !== current.major && policy.allowMajor !== true) return false
+  return true
+}
+
+/** A dependency value that names a mutable range rather than a pin or a local path. */
+export function isFloatingSpec(spec) {
+  const text = String(spec ?? "").trim()
+  if (text === "") return false
+  if (/^(link|file|workspace|portal|git|github|https?):/.test(text)) return false
+  // Path specs point at a checkout, whose version is whatever that checkout says.
+  if (/^\.{1,2}\//.test(text) || text.startsWith("/") || text.startsWith("~/")) return false
+  if (/^(npm|jsr):/.test(text)) return true
+  // `1.2.3` / `=1.2.3` are pins; `^1.2.3`, `~1.2.3`, `>=1`, `*`, `latest` are ranges.
+  return !/^=?v?\d+\.\d+\.\d+([-+][0-9A-Za-z.-]+)?$/.test(text)
+}
+
+/**
+ * Pick the bundles worth looking at: installed through the profile, version
+ * known, no manager error, not a local path, and named by the allowlist.
+ */
+export function selectCandidates(bundles, packages) {
+  const allow = Array.isArray(packages) ? packages : ["*"]
+  const everything = allow.includes("*")
+  return (bundles ?? []).filter((bundle) => {
+    if (bundle === null || typeof bundle !== "object") return false
+    if (bundle.availability !== "profile") return false
+    if (bundle.installed !== true) return false
+    if (typeof bundle.name !== "string" || typeof bundle.version !== "string") return false
+    if (bundle.error !== undefined) return false
+    if (!isFloatingSpec(bundle.source)) return false
+    return everything || allow.includes(bundle.name)
+  })
+}
+
+/** Read the newest published version of one package. */
+export async function newestVersion(registry, name, options = {}) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch
+  const timeoutMs = options.timeoutMs ?? DEFAULTS.timeoutMs
+  if (typeof fetchImpl !== "function") return { error: "fetch is unavailable" }
+  const base = String(registry ?? DEFAULTS.registry).replace(/\/+$/, "")
+  const encoded = name.startsWith("@") ? name.replace("/", "%2F") : encodeURIComponent(name)
+  const url = `${base}/${encoded}/latest`
+  try {
+    const response = await fetchImpl(url, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(timeoutMs),
+    })
+    if (response.ok !== true) return { error: `registry answered ${String(response.status)}` }
+    const body = await response.json()
+    if (typeof body?.version !== "string") return { error: "registry answer has no version" }
+    return { version: body.version }
+  } catch (error) {
+    return { error: String(error?.message ?? error) }
+  }
+}
+
+/** Merge the stored settings over the defaults, ignoring unknown keys. */
+export function resolveSettings(stored) {
+  const resolved = { ...DEFAULTS }
+  for (const key of Object.keys(DEFAULTS)) {
+    const value = stored?.[key]
+    if (value === undefined) continue
+    if (Array.isArray(DEFAULTS[key])) {
+      if (Array.isArray(value) && value.every((item) => typeof item === "string")) resolved[key] = value
+      continue
+    }
+    if (typeof DEFAULTS[key] === "number") {
+      if (typeof value === "number" && Number.isFinite(value)) resolved[key] = value
+      continue
+    }
+    if (typeof DEFAULTS[key] === "boolean") {
+      if (typeof value === "boolean") resolved[key] = value
+      continue
+    }
+    if (typeof value === "string" && value !== "") resolved[key] = value
+  }
+  return resolved
+}
+
+/** One line per action, JSON so it stays greppable. */
+export async function appendLog(path, entry) {
+  const target = expandHome(path)
+  await mkdir(dirname(target), { recursive: true })
+  await appendFile(target, `${JSON.stringify(entry)}\n`, "utf8")
+}
+
+/** A desktop banner on macOS; other platforms keep the log line only. */
+function announce(title, body) {
+  if (process.platform !== "darwin") return
+  try {
+    execFile(
+      "/usr/bin/osascript",
+      [
+        "-e",
+        'on run argv\n display notification (item 1 of argv) with title (item 2 of argv)\nend run',
+        body,
+        title,
+      ],
+      { timeout: 10000 },
+      () => {},
+    )
+  } catch {
+    /* a banner is best effort */
+  }
+}
+
+/** The outcome of handing the update to the plugin manager. */
+function outcomeOf(result, fallback) {
+  if (result === null || typeof result !== "object") return { application: fallback }
+  if (result.application === "failed") {
+    const reason = result.error?.code ?? result.error?.message ?? "unknown"
+    return { application: "failed", reason: String(reason) }
+  }
+  return {
+    application: typeof result.application === "string" ? result.application : fallback,
+    ...result.restartReason === undefined ? {} : { restartReason: result.restartReason },
+  }
+}
+
+/**
+ * One updater instance: a settings file, a plugin manager, and a log.
+ * Everything external is injected so the cycle can be tested without a desktop.
+ */
+export function createUpdater(options = {}) {
+  const managerOf = typeof options.manager === "function" ? options.manager : () => options.manager
+  const readSettings = typeof options.readSettings === "function"
+    ? options.readSettings
+    : () => resolveSettings(options.config ?? {})
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch
+  const logPath = options.logPath ?? DEFAULTS.logPath
+  let running = false
+  let lastRunAt = 0
+  // `plugin-manager/changed` fires around our own install, so a short cooldown
+  // keeps one update from turning into a burst of registry lookups.
+  const cooldownMs = options.cooldownMs ?? 5000
+
+  const log = async (entry) => {
+    try {
+      await appendLog(logPath, { at: new Date().toISOString(), ...entry })
+    } catch {
+      /* the log must never break a cycle */
+    }
+  }
+
+  const updateOne = async (bundle, latest) => {
+    const manager = managerOf()
+    if (manager === undefined) return { ok: false, error: "pluginManager is gone" }
+    let removed
+    try {
+      removed = await manager.removeBundle(bundle.name)
+    } catch (error) {
+      return { ok: false, error: String(error?.message ?? error) }
+    }
+    const removal = outcomeOf(removed, "applied")
+    if (removal.application === "failed") return { ok: false, error: `remove failed: ${removal.reason}` }
+    let installed
+    try {
+      installed = await manager.installBundle(`${bundle.name}@${latest}`, { enabled: true })
+    } catch (error) {
+      // Put the previous version back: leaving the bundle uninstalled would be
+      // worse than the failed update.
+      try {
+        await manager.installBundle(`${bundle.name}@${bundle.version}`, { enabled: true })
+      } catch {
+        /* the rollback is best effort; the log names it either way */
+      }
+      return { ok: false, error: String(error?.message ?? error), rolledBack: true }
+    }
+    const installing = outcomeOf(installed, "applied")
+    if (installing.application === "failed") {
+      try {
+        await manager.installBundle(`${bundle.name}@${bundle.version}`, { enabled: true })
+      } catch {
+        /* see above */
+      }
+      return { ok: false, error: `install failed: ${installing.reason}`, rolledBack: true }
+    }
+    return { ok: true, application: installing.application, restartReason: installing.restartReason }
+  }
+
+  const runOnce = async (runOptions = {}) => {
+    if (running) return { skipped: "busy" }
+    if (runOptions.force !== true && Date.now() - lastRunAt < cooldownMs) return { skipped: "cooldown" }
+    running = true
+    lastRunAt = Date.now()
+    try {
+      const resolved = readSettings()
+      const manager = managerOf()
+      if (manager === undefined) {
+        await log({ kind: "cycle", skipped: "no-plugin-manager" })
+        return { skipped: "no-plugin-manager" }
+      }
+      const bundles = await manager.listBundles()
+      const candidates = selectCandidates(bundles, resolved.packages)
+      if (resolved.enabled !== true) {
+        await log({ kind: "cycle", skipped: "disabled", candidates: candidates.map((item) => item.name) })
+        return { skipped: "disabled", candidates: candidates.length }
+      }
+      const decisions = []
+      let changed = 0
+      for (const bundle of candidates) {
+        if (changed >= resolved.maxUpdatesPerRun) break
+        const newest = await newestVersion(resolved.registry, bundle.name, {
+          fetchImpl,
+          timeoutMs: resolved.timeoutMs,
+        })
+        if (newest.error !== undefined) {
+          decisions.push({ name: bundle.name, action: "error", reason: newest.error })
+          continue
+        }
+        if (!acceptsUpdate(bundle.version, newest.version, resolved)) {
+          decisions.push({ name: bundle.name, action: "current", installed: bundle.version, latest: newest.version })
+          continue
+        }
+        if (resolved.dryRun === true) {
+          decisions.push({ name: bundle.name, action: "would-update", installed: bundle.version, latest: newest.version })
+          continue
+        }
+        const outcome = await updateOne(bundle, newest.version)
+        changed += outcome.ok ? 1 : 0
+        decisions.push({
+          name: bundle.name,
+          action: outcome.ok ? "updated" : "failed",
+          installed: bundle.version,
+          latest: newest.version,
+          ...outcome.ok
+            ? { application: outcome.application, ...outcome.restartReason === undefined ? {} : { restartReason: outcome.restartReason } }
+            : { reason: outcome.error, rolledBack: outcome.rolledBack === true },
+        })
+      }
+      await log({ kind: "cycle", decisions })
+      const updated = decisions.filter((item) => item.action === "updated")
+      if (updated.length > 0) {
+        const names = updated.map((item) => `${item.name} → ${item.latest}`).join(", ")
+        await log({ kind: "notify", names })
+        if (options.announce ?? true) {
+          announce("DSH 插件已自动更新", `${names}${updated.some((item) => item.restartReason !== undefined) ? "，重启后生效" : ""}`)
+        }
+      }
+      return { decisions, updated: updated.length }
+    } finally {
+      running = false
+    }
+  }
+
+  return { runOnce, log, settings: () => readSettings() }
+}
+

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "DSH Plugin Auto Update",
+    "description": "Keeps the plugins you tick on their newest release: checks npm on a schedule and updates through the plugin manager, rolling back on failure."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "DSH 插件自动更新",
+    "description": "按你勾选的插件自动保持最新版本：定时检查 npm，直接通过插件管理器完成更新，失败会回滚。"
+  }
+}

package/package.json

@@ -1,6 +1,62 @@
 {
   "name": "@chendaleiq/dsh-plugin-auto-update",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.16",
+  "description": "Automatic updates for the plugin bundles you choose in DeepSeek Harness, per package, through the plugin manager",
+  "license": "MIT",
+  "type": "module",
+  "main": "index.js",
+  "author": "chendaleiQ",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chendaleiQ/dsh-plugin-auto-update.git"
+  },
+  "homepage": "https://github.com/chendaleiQ/dsh-plugin-auto-update#readme",
+  "bugs": {
+    "url": "https://github.com/chendaleiQ/dsh-plugin-auto-update/issues"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "plugin-updater",
+    "auto-update"
+  ],
+  "files": [
+    "index.js",
+    "lib/",
+    "locale/",
+    "icon.svg",
+    "cordis.patch.yml",
+    "README.md",
+    "README.en.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node test/index.test.mjs"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-plugin-manager",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
+    }
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./lib/client.js",
+    "./icon": "./icon.svg",
+    "./locale/*.json": "./locale/*.json",
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/schemastery": "*"
+  },
+  "icon": "./icon.svg",
+  "publishConfig": {
+    "access": "public"
+  }
+}