dsh-plugin-syncup 4.0.0 → 4.1.0

package/lib/sync.js

@@ -7,8 +7,9 @@ import { emptyManifest, localHostEntry, mergeHost, pickInstallSpec, summarizeMan
 import { buildPreview, selectPreviewEntries } from './preview.js'
 import { applyPushPlan, buildPushPlan } from './pushplan.js'
 import { manualUpdateInstructions, resolveProfileDir } from './manual.js'
+import { parseVersion } from './spec.js'
 import { readState, resolveStatePath, writeState } from './state.js'
-import { createVersionChecker, gitHubTargetOf, registryNameOf } from './versions.js'
+import { createVersionChecker, gitHubTargetOf, isPrereleaseVersion, registryNameOf } from './versions.js'
 
 const PREVIEW_TTL_MS = 10 * 60 * 1000
 const MAX_HISTORY = 20
@@ -228,6 +229,94 @@ export function createSyncRuntime({
     }
   }
 
+  /**
+   * Replace an installed registry bundle through the plugin manager's own update
+   * path, when this DSH version has one.
+   *
+   * dsh 0.2.2 added `updateBundle(name, version)`: it checks the target on the
+   * registry, removes the running copy under HMR, installs the new version with
+   * the same selection, and reinstalls the old version when that fails. That is
+   * exactly the remove-then-install dance this plugin used to perform by hand,
+   * but done atomically inside the manager, so it is preferred whenever it is
+   * available and applies.
+   *
+   * It only handles bundles installed from a registry under their own name, and
+   * requires a strictly newer semver. Anything else returns `null` and the caller
+   * falls back to the generic install path.
+   */
+  function registryUpdateFor(name, version) {
+    if (typeof pluginManager?.updateBundle !== 'function') return null
+    const wanted = String(version ?? '').trim()
+    if (wanted === '' || parseVersion(wanted) === null || isPrereleaseVersion(wanted)) return null
+    return { name, version: wanted }
+  }
+
+  /** The exact version inside `name@1.2.3`, or `''` for any other spec shape. */
+  function versionFromSpec(spec) {
+    if (typeof spec !== 'string' || /[:\s]/.test(spec)) return ''
+    const at = spec.lastIndexOf('@')
+    if (at <= 0) return ''
+    const version = spec.slice(at + 1)
+    return parseVersion(version) === null ? '' : version
+  }
+
+  async function updateViaManager({ name, version, job }) {
+    jobLog(job, 'info', `${name}: updating to ${version} through the plugin manager`)
+    try {
+      const outcome = await pluginManager.updateBundle(name, version)
+      const step = outcome?.step ?? 'update'
+      const result = outcome?.result ?? outcome
+      const failure = step === 'install' || step === 'remove' || step === 'check'
+        ? changeError(result ?? {})
+        : null
+      if (failure !== null) {
+        jobLog(job, 'error', `${name}: update failed — ${failure.message}`)
+        return {
+          name,
+          spec: `${name}@${version}`,
+          status: 'failed',
+          error: failure.message,
+          ...(failure.code ? { code: failure.code } : {}),
+          ...(outcome?.restore === undefined ? {} : { rollback: 'failed' }),
+        }
+      }
+      if (result?.application === 'failed' || result?.application === 'cancelled') {
+        jobLog(job, 'error', `${name}: update ${result.application}`)
+        return {
+          name,
+          spec: `${name}@${version}`,
+          status: 'failed',
+          error: `the plugin manager ${result.application} the update`,
+          ...(outcome?.restore === undefined ? {} : { rollback: 'failed' }),
+        }
+      }
+      const restored = outcome?.restore !== undefined && outcome.restore.application !== 'failed'
+      jobLog(
+        job,
+        'info',
+        `${name}: ${restored ? 'restored the previous version' : 'updated'} to ${version}`
+        + `${result?.application === 'restart-required' ? ' (restart required)' : ''}`,
+      )
+      return {
+        name,
+        spec: `${name}@${version}`,
+        status: 'installed',
+        version,
+        ...(outcome?.from === undefined ? {} : { replaced: outcome.from }),
+        ...(outcome?.from === undefined ? {} : { upgraded: true }),
+        ...(restored ? { rollback: 'restored' } : {}),
+        ...(result?.application === 'restart-required' ? { restartRequired: true } : {}),
+        ...(Array.isArray(result?.warnings) && result.warnings.length > 0
+          ? { warnings: result.warnings.slice(0, 10) }
+          : {}),
+      }
+    } catch (error) {
+      const info = errorInfo(error)
+      jobLog(job, 'error', `${name}: update failed — ${info.message}`)
+      return { name, spec: `${name}@${version}`, status: 'failed', ...info }
+    }
+  }
+
   /**
    * Install a bundle, replacing an installed copy when the manager refuses it.
    *
@@ -276,14 +365,36 @@ export function createSyncRuntime({
 
     const known = await findManualUpdate(name)
     if (known !== null) {
-      jobLog(job, 'warn', `${name}: previously required a manual update; skipping`)
-      return {
-        ...first,
-        code: 'manual-update',
-        error: `${first.error ?? 'already-installed'} This bundle could not be unloaded by HMR before (${known.at}), so it was left untouched.`,
-        hint: 'manual-terminal',
-        manual: instructionsFor(name, spec),
+      // A remembered failure predates this DSH's own update path. When the manager
+      // can now replace the bundle itself, that memory is stale — retry instead of
+      // skipping forever.
+      const retry = registryUpdateFor(name, versionFromSpec(spec))
+      if (retry === null) {
+        jobLog(job, 'warn', `${name}: previously required a manual update; skipping`)
+        return {
+          ...first,
+          code: 'manual-update',
+          error: `${first.error ?? 'already-installed'} This bundle could not be unloaded by HMR before (${known.at}), so it was left untouched.`,
+          hint: 'manual-terminal',
+          manual: instructionsFor(name, spec),
+        }
+      }
+      jobLog(job, 'info', `${name}: the plugin manager can update it now; retrying instead of skipping`)
+      await forgetManualUpdate(name)
+    }
+
+    // The manager's own update path handles the swap atomically; prefer it.
+    const native = registryUpdateFor(name, versionFromSpec(spec))
+    if (native !== null) {
+      const updated = await updateViaManager({ ...native, job })
+      if (updated.status !== 'failed' && updated.rollback === undefined) {
+        await clearPendingUpgrade(name)
+        await forgetManualUpdate(name)
+        return { ...updated, upgraded: updated.rollback === undefined, replaced: record.fromVersion || record.fromSpec }
       }
+      // A failed native update already restored the previous version; report it
+      // rather than trying the manual dance on top.
+      return updated
     }
 
     jobLog(job, 'warn', `${name}: already installed; replacing ${record.fromVersion || record.fromSpec} with ${spec}`)
@@ -1163,11 +1274,20 @@ export function createSyncRuntime({
         return raw === 'npm' || raw === 'github' ? raw : null
       }
 
-      // One job for the whole action: the scoped check writes its lines into it,
-      // so the page shows a single log whose counts are the selected bundles.
+      // One job for the whole action: the check writes its lines into it, so the
+      // page shows a single log whose counts are the selected bundles.
       const job = jobs.start('apply-latest', { total: selected.length })
-      const checked = await runLatestCheck({ signal, only: selected, job })
-      const byName = new Map(checked.entries.map((entry) => [entry.name, entry]))
+      // Reuse the result the user just looked at. Re-checking here made an update
+      // look like "check again, change nothing": the registry was queried a second
+      // time and the row's outcome was recomputed instead of acted on. Only ask
+      // for entries the cache does not already cover.
+      const cached = latestCache === null ? null : latestCache.result
+      const covered = new Set((cached?.entries ?? []).map((entry) => entry.name))
+      const missing = selected.filter((name) => !covered.has(name))
+      const checked = missing.length === 0 && cached !== null
+        ? cached
+        : await runLatestCheck({ signal, only: missing.length === 0 ? selected : missing, job })
+      const byName = new Map([...(cached?.entries ?? []), ...checked.entries].map((entry) => [entry.name, entry]))
       const targeted = []
       const skipped = []
       for (const name of selected) {
@@ -1232,7 +1352,16 @@ export function createSyncRuntime({
           continue
         }
         jobLog(job, 'info', `${entry.name}: installing ${target} (${chosenChannel ?? 'auto'})`)
-        const summary = await installOrUpgrade({ name: entry.name, spec: target, previous: current, job })
+        // Prefer the manager's own update path: it removes, installs, and restores
+        // on failure inside one call, which is exactly what the manual dance below
+        // approximates. It only applies to a registry package updated to a strictly
+        // newer version, so anything else falls through.
+        const nativeUpdate = chosenChannel === null || chosenChannel === 'npm'
+          ? registryUpdateFor(entry.name, entry.channels?.npm ?? entry.npmLatest ?? null)
+          : null
+        const summary = nativeUpdate !== null
+          ? await updateViaManager({ ...nativeUpdate, job })
+          : await installOrUpgrade({ name: entry.name, spec: target, previous: current, job })
         if (summary.status === 'failed') {
           failed.push({
             name: entry.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-syncup",
-  "version": "4.0.0",
+  "version": "4.1.0",
   "description": "Sync plugin inventories through a secret GitHub Gist and update every plugin to its newest release, with conflict-aware preview and an install log.",
   "type": "module",
   "icon": "icon.svg",