@huaqiu/dsh-tool-plugin-update 0.5.22 → 0.6.2

package/src/client/update-view.ts

@@ -21,9 +21,14 @@ import {
   checkUpdates,
   ignoreOffer,
   installSet,
+  requestRuntimeUpdate,
+  runtimeLatestVersion,
+  setPluginUpdateSource,
+  setRuntimeUpdateSource,
   unignoreOffer,
   type PluginUpdateItem,
   type PluginUpdateReport,
+  type RuntimeUpdateSource,
 } from './api.js'
 import type { UpdateCopy } from './copy.js'
 import {
@@ -262,8 +267,261 @@ function skeleton(copy: UpdateCopy): HTMLElement {
   return section
 }
 
+/** Mutable editor state for one manifest source (lives in the panel closure). */
+interface SourceState {
+  editing: boolean
+  saving: boolean
+  draft: string
+}
+
+/**
+ * Shared state + callbacks for one update-source editor.
+ *
+ * hq-edge serves both manifest sources from one shape (plugin release
+ * manifest, runtime-update manifest), and both are editable from this panel:
+ * an override is persisted per host, so pointing discovery at a staging
+ * channel (or a local test rig) needs no env var and no restart. The editor
+ * state lives in the panel closure for the same reason `armed` does — a store
+ * refresh must not discard a half-typed URL or silently close the editor.
+ */
+export interface SourceEditorActions {
+  /** The source editor is open (input shown instead of the read-only row). */
+  sourceEditing: boolean
+  /** A save is in flight. */
+  sourceSaving: boolean
+  /** The URL being edited (what the input shows). */
+  sourceDraft: string
+  onSourceEdit(): void
+  onSourceDraft(value: string): void
+  onSourceSave(): void
+  onSourceCancel(): void
+  /** Clear the user override, falling back to the configured URL. */
+  onSourceReset(): void
+}
+
+/**
+ * The runtime-update action row's state and callbacks.
+ *
+ * Installing the runtime is destructive in a way a plugin install is not: hq-edge
+ * shuts itself down so the EDA host can swap the runtime directory. So the row
+ * is a two-step confirm (arm → confirm), never a single fire-and-forget click.
+ */
+export interface RuntimeActions extends SourceEditorActions {
+  /** A request is in flight (hq-edge accepted it and is restarting). */
+  busy: boolean
+  /** The confirm step is armed for the version the row names. */
+  armed: boolean
+  /**
+   * hq-edge answered `202 Accepted`: from here on the outcome belongs to the
+   * EDA host, and this process is about to be replaced. Terminal — the row
+   * must never re-offer the button once this is true, because hq-edge is
+   * already gone and a second request could only fail.
+   */
+  accepted: boolean
+  onArm(): void
+  onConfirm(): void
+  onCancel(): void
+}
+
+/**
+ * Normalize the report's `runtime.source` to the full shape.
+ *
+ * An older hq-edge predates the feature and sends no `source` at all — that
+ * must degrade to a read-only panel, not crash the render. A future server
+ * may add fields; unknown extras are dropped here rather than trusted.
+ */
+function normalizeSource(raw: unknown): RuntimeUpdateSource | null {
+  if (raw === null || typeof raw !== 'object') return null
+  const candidate = raw as Partial<RuntimeUpdateSource>
+  if (typeof candidate.origin !== 'string') return null
+  return {
+    url: typeof candidate.url === 'string' ? candidate.url : '',
+    origin: candidate.origin as RuntimeUpdateSource['origin'],
+    configuredUrl: typeof candidate.configuredUrl === 'string' ? candidate.configuredUrl : '',
+    override: candidate.override === true,
+  }
+}
+
+/** The tag naming where the URL in effect came from. */
+function originLabel(origin: RuntimeUpdateSource['origin'], copy: UpdateCopy): string {
+  switch (origin) {
+    case 'override':
+      return copy.originOverride
+    case 'config':
+      return copy.originConfig
+    default:
+      return copy.originUnset
+  }
+}
+
+/** The 更新源 fact row: the URL in effect plus an origin tag. */
+function sourceFactRow(
+  facts: HTMLElement,
+  source: RuntimeUpdateSource,
+  copy: UpdateCopy,
+): void {
+  const wrap = el('div')
+  wrap.append(el('dt', '', copy.runtime.source))
+  const dd = el('dd')
+  const line = el('div', 'hqpu-source-line')
+  const code = el(
+    'code',
+    'hqpu-source-url',
+    source.url.length > 0 ? source.url : copy.runtime.notConfigured,
+  )
+  const tag = el('span', 'hqpu-tag')
+  tag.dataset.tone = source.override ? 'info' : source.origin === 'config' ? 'success' : 'neutral'
+  tag.textContent = originLabel(source.origin, copy)
+  line.append(code, tag)
+  dd.append(line)
+  wrap.append(dd)
+  facts.append(wrap)
+}
+
+/** Which manifest an editor belongs to — drives data attributes + CSS hook. */
+export type SourceKind = 'runtime' | 'plugin'
+
+/** The localized strings one source editor needs (both kinds share the flow). */
+interface SourceEditorLabels {
+  hint: string
+  edit: string
+  save: string
+  reset: string
+  inputLabel: string
+  placeholder: string
+}
+
+/** Pick the labels for one kind out of the copy table. */
+function sourceLabels(copy: UpdateCopy, kind: SourceKind): SourceEditorLabels {
+  return kind === 'runtime'
+    ? {
+        hint: copy.runtime.sourceHint,
+        edit: copy.runtime.sourceEdit,
+        save: copy.runtime.sourceSave,
+        reset: copy.runtime.sourceReset,
+        inputLabel: copy.runtime.sourceInputLabel,
+        placeholder: copy.runtime.sourcePlaceholder,
+      }
+    : {
+        hint: copy.pluginSource.hint,
+        edit: copy.pluginSource.edit,
+        save: copy.pluginSource.save,
+        reset: copy.pluginSource.reset,
+        inputLabel: copy.pluginSource.inputLabel,
+        placeholder: copy.pluginSource.placeholder,
+      }
+}
+
+/**
+ * One update-source editor, shared by the plugin manifest and the runtime
+ * manifest (the only differences are the labels and the data-attribute
+ * prefix, so tests and CSS can target each).
+ *
+ * Read mode is a hint plus a 修改 button; edit mode is the URL field with
+ * 保存 / 取消 — plus 恢复默认 while a user override shadows the configured
+ * URL. The draft lives in {@link SourceEditorActions} (the panel closure), so
+ * a background store refresh re-renders the typed URL instead of discarding it.
+ */
+function sourceEditor(
+  kind: SourceKind,
+  source: RuntimeUpdateSource,
+  copy: UpdateCopy,
+  actions: SourceEditorActions,
+): HTMLElement {
+  const labels = sourceLabels(copy, kind)
+  const block = el('div', `hqpu-source-editor hqpu-source-editor--${kind}`)
+  if (!actions.sourceEditing) {
+    block.append(el('p', 'hqpu-status hqpu-source-hint', labels.hint))
+    const edit = el('button', 'hqpu-btn hqpu-btn--outline hqpu-btn--sm', labels.edit)
+    edit.type = 'button'
+    edit.setAttribute(`data-${kind}-source-edit`, '')
+    edit.disabled = actions.sourceSaving
+    edit.addEventListener('click', actions.onSourceEdit)
+    block.append(edit)
+    return block
+  }
+  const input = el('input', 'hqpu-source-input')
+  input.type = 'url'
+  input.value = actions.sourceDraft
+  input.placeholder = labels.placeholder
+  input.setAttribute('aria-label', labels.inputLabel)
+  input.setAttribute(`data-${kind}-source-input`, '')
+  input.disabled = actions.sourceSaving
+  input.addEventListener('input', () => {
+    // Draft-only: no re-render, so the caret and IME stay untouched.
+    actions.onSourceDraft(input.value)
+  })
+  // Enter saves, Escape cancels — the field is the whole editor, and Escape
+  // must not fall through to the panel-wide close handler.
+  input.addEventListener('keydown', (ev) => {
+    if (ev.key === 'Enter') {
+      ev.preventDefault()
+      actions.onSourceSave()
+    } else if (ev.key === 'Escape') {
+      ev.preventDefault()
+      ev.stopPropagation()
+      actions.onSourceCancel()
+    }
+  })
+  const save = el('button', 'hqpu-btn hqpu-btn--primary hqpu-btn--sm', labels.save)
+  save.type = 'button'
+  save.setAttribute(`data-${kind}-source-save`, '')
+  save.disabled = actions.sourceSaving
+  save.addEventListener('click', actions.onSourceSave)
+  const cancel = el('button', 'hqpu-btn hqpu-btn--outline hqpu-btn--sm', copy.cancel)
+  cancel.type = 'button'
+  cancel.setAttribute(`data-${kind}-source-cancel`, '')
+  cancel.disabled = actions.sourceSaving
+  cancel.addEventListener('click', actions.onSourceCancel)
+  const controls = el('div', 'hqpu-actions hqpu-source-controls')
+  controls.append(input, save, cancel)
+  if (source.override) {
+    const reset = el('button', 'hqpu-btn hqpu-btn--ghost hqpu-btn--sm', labels.reset)
+    reset.type = 'button'
+    reset.setAttribute(`data-${kind}-source-reset`, '')
+    reset.disabled = actions.sourceSaving
+    reset.addEventListener('click', actions.onSourceReset)
+    controls.append(reset)
+  }
+  block.append(controls)
+  // Focus on open — and on any re-render while editing, which is exactly what
+  // a rejected save wants (the user is dropped back into the field to fix it).
+  input.focus()
+  return block
+}
+
+/**
+ * The plugin release-manifest source, as its own group above the plugin
+ * groups: it says where the whole list comes from, so it belongs above the
+ * list rather than inside it. Absent on an older hq-edge (no `pluginSource`
+ * in the report) — then nothing is rendered at all.
+ */
+function pluginSourceGroup(
+  report: PluginUpdateReport,
+  copy: UpdateCopy,
+  actions: SourceEditorActions,
+): HTMLElement | null {
+  const source = normalizeSource(report.pluginSource)
+  if (source === null) return null
+  const section = el('section', 'hqpu-group')
+  section.dataset.group = 'plugin-source'
+  const head = el('div', 'hqpu-group-head')
+  head.append(el('h3', 'hqpu-group-title', copy.pluginSource.title))
+  section.append(head)
+
+  const facts = el('dl', 'hqpu-facts')
+  sourceFactRow(facts, source, copy)
+  section.append(facts)
+  section.append(sourceEditor('plugin', source, copy, actions))
+  return section
+}
+
 /** The independent HQ Edge runtime report, as ruled fact rows. */
-function runtimeGroup(report: PluginUpdateReport, copy: UpdateCopy): HTMLElement {
+function runtimeGroup(
+  report: PluginUpdateReport,
+  copy: UpdateCopy,
+  actions: RuntimeActions,
+): HTMLElement {
   const section = el('section', 'hqpu-group')
   section.dataset.group = 'runtime'
   const head = el('div', 'hqpu-group-head')
@@ -272,6 +530,9 @@ function runtimeGroup(report: PluginUpdateReport, copy: UpdateCopy): HTMLElement
 
   const facts = el('dl', 'hqpu-facts')
   const runtime = report.runtime
+  // `runtime.latest` is a release ENTRY; only its version is ever displayed or
+  // sent back as `targetVersion`.
+  const latestVersion = runtimeLatestVersion(runtime)
 
   const row = (label: string, value: string, code = false): void => {
     const wrap = el('div')
@@ -287,12 +548,20 @@ function runtimeGroup(report: PluginUpdateReport, copy: UpdateCopy): HTMLElement
     facts.append(wrap)
   }
 
+  // The source row: which manifest URL is in effect and where it came from.
+  // Absent on an older hq-edge — then only the legacy notConfigured row shows.
+  const source = normalizeSource(runtime.source)
+
   if (runtime.configured === false) {
-    row(copy.runtime.source, copy.runtime.notConfigured)
+    if (source !== null) {
+      sourceFactRow(facts, source, copy)
+    } else {
+      row(copy.runtime.source, copy.runtime.notConfigured)
+    }
   } else {
     row(copy.runtime.current, runtime.currentVersion ?? copy.runtime.unknown)
-    if (runtime.updateAvailable && runtime.latest != null) {
-      row(copy.runtime.latest, runtime.latest)
+    if (runtime.updateAvailable && latestVersion !== null) {
+      row(copy.runtime.latest, latestVersion)
     }
     if (report.manifestVersion !== null) {
       row(copy.runtime.set, report.manifestVersion, true)
@@ -300,10 +569,62 @@ function runtimeGroup(report: PluginUpdateReport, copy: UpdateCopy): HTMLElement
     if (typeof runtime.checkedAt === 'string' && runtime.checkedAt.length > 0) {
       row(copy.runtime.checkedAt, new Date(runtime.checkedAt).toLocaleString())
     }
+    if (source !== null) {
+      sourceFactRow(facts, source, copy)
+    }
   }
   section.append(facts)
 
-  section.append(el('p', 'hqpu-status', copy.runtime.note))
+  // The editor: point the runtime at another release channel (a staging
+  // manifest, a local rig) without an env var and a restart. hq-edge persists
+  // the override per host, so it survives restarts of both processes.
+  if (source !== null) {
+    section.append(sourceEditor('runtime', source, copy, actions))
+  }
+
+  // ── Runtime update action row ──
+  // Only offered when hq-edge reports a newer distribution AND named its
+  // version: the request needs `targetVersion`, so an entry without one has
+  // nothing to send.
+  if (runtime.updateAvailable && latestVersion !== null) {
+    const row = el('div', 'hqpu-actions hqpu-runtime-actions')
+    if (actions.accepted) {
+      // Terminal state: no button. hq-edge has already exited, so re-offering
+      // "update" here could only produce a transport error.
+      const line = el('span', 'hqpu-status hqpu-status--dot')
+      line.setAttribute('role', 'status')
+      line.append(el('span', 'hqpu-spinner'), el('span', '', copy.runtime.updateAccepted))
+      row.append(line)
+    } else if (actions.busy) {
+      // Downloading + verifying + staging the bundle: tens of seconds to a few
+      // minutes. Say what is happening instead of an open-ended spinner.
+      const line = el('span', 'hqpu-status hqpu-status--dot')
+      line.setAttribute('role', 'status')
+      line.append(el('span', 'hqpu-spinner'), el('span', '', copy.runtime.updating))
+      row.append(line)
+    } else if (actions.armed) {
+      row.append(el('p', 'hqpu-status hqpu-runtime-confirm', copy.runtime.updateConfirm(latestVersion)))
+      const yes = el('button', 'hqpu-btn hqpu-btn--primary hqpu-btn--sm', copy.confirmInstall)
+      yes.type = 'button'
+      yes.dataset.runtimeConfirm = ''
+      yes.addEventListener('click', actions.onConfirm)
+      const no = el('button', 'hqpu-btn hqpu-btn--outline hqpu-btn--sm', copy.cancel)
+      no.type = 'button'
+      no.addEventListener('click', actions.onCancel)
+      row.append(yes, no)
+    } else {
+      const start = el('button', 'hqpu-btn hqpu-btn--primary hqpu-btn--sm')
+      start.type = 'button'
+      start.dataset.runtimeUpdate = ''
+      start.innerHTML = `${DOWNLOAD_ICON(13)}<span>${copy.runtime.update}</span>`
+      start.addEventListener('click', actions.onArm)
+      row.append(start)
+    }
+    section.append(row)
+  } else {
+    section.append(el('p', 'hqpu-status', copy.runtime.note))
+  }
+
   if (typeof runtime.lastError === 'string' && runtime.lastError.length > 0) {
     const line = el('p', 'hqpu-status hqpu-status--dot')
     line.setAttribute('role', 'status')
@@ -353,10 +674,24 @@ function renderRuntime(
   section: HTMLElement,
   report: PluginUpdateReport | null,
   copy: UpdateCopy,
+  actions: RuntimeActions,
 ): void {
   section.textContent = ''
   if (report === null) return
-  section.append(runtimeGroup(report, copy))
+  section.append(runtimeGroup(report, copy, actions))
+}
+
+/** The plugin-source group, above the plugin groups. No-op without the field. */
+function renderPluginSource(
+  section: HTMLElement,
+  report: PluginUpdateReport | null,
+  copy: UpdateCopy,
+  actions: SourceEditorActions,
+): void {
+  section.textContent = ''
+  if (report === null) return
+  const node = pluginSourceGroup(report, copy, actions)
+  if (node !== null) section.append(node)
 }
 
 /** Run the install transaction, then keep polling until the state settles. */
@@ -548,10 +883,11 @@ export function openUpdateView(store: UpdateStoreLike, copy: UpdateCopy): void {
   // ── Scrolling body: the centred column ──
   const scroll = el('div', 'hqpu-scroll')
   const column = el('div', 'hqpu-column')
+  const pluginSourceSection = el('div', 'hqpu-stack')
   const listSection = el('div', 'hqpu-stack')
   const runtimeSection = el('div', 'hqpu-stack')
   const toastSection = el('div', 'hqpu-toast-host')
-  column.append(listSection, runtimeSection, toastSection)
+  column.append(pluginSourceSection, listSection, runtimeSection, toastSection)
   scroll.append(column)
   panel.append(scroll)
 
@@ -568,6 +904,174 @@ export function openUpdateView(store: UpdateStoreLike, copy: UpdateCopy): void {
 
   const disposers: Array<() => void> = []
 
+  // ── Runtime update: arm → confirm, then hand off to hq-edge ──
+  // Live in the panel's closure (not the report) because they are UI state, and
+  // a store refresh must not silently disarm a confirm the user just armed.
+  let runtimeArmed = false
+  let runtimeBusy = false
+  let runtimeAccepted = false
+
+  // Source-editor state, same reasoning: a background refresh must not discard
+  // a half-typed URL or silently close either editor.
+  const runtimeSourceState: SourceState = { editing: false, saving: false, draft: '' }
+  const pluginSourceState: SourceState = { editing: false, saving: false, draft: '' }
+
+  // Delegated, not spread: `...sourceActionsFor(...)` would evaluate the
+  // getters once and freeze `sourceEditing: false` — the editor would never
+  // open. Read every member through the live object instead.
+  const runtimeSourceActions = sourceActionsFor('runtime', runtimeSourceState)
+  const runtimeActions: RuntimeActions = {
+    get busy() {
+      return runtimeBusy
+    },
+    get armed() {
+      return runtimeArmed
+    },
+    get accepted() {
+      return runtimeAccepted
+    },
+    onArm: () => {
+      runtimeArmed = true
+      render()
+    },
+    onCancel: () => {
+      runtimeArmed = false
+      render()
+    },
+    onConfirm: () => {
+      void requestRuntime()
+    },
+    get sourceEditing() {
+      return runtimeSourceActions.sourceEditing
+    },
+    get sourceSaving() {
+      return runtimeSourceActions.sourceSaving
+    },
+    get sourceDraft() {
+      return runtimeSourceActions.sourceDraft
+    },
+    onSourceEdit: () => runtimeSourceActions.onSourceEdit(),
+    onSourceDraft: (value: string) => runtimeSourceActions.onSourceDraft(value),
+    onSourceSave: () => runtimeSourceActions.onSourceSave(),
+    onSourceCancel: () => runtimeSourceActions.onSourceCancel(),
+    onSourceReset: () => runtimeSourceActions.onSourceReset(),
+  }
+
+  const pluginActions: SourceEditorActions = sourceActionsFor('plugin', pluginSourceState)
+
+  /** Build the {@link SourceEditorActions} half for one manifest source. */
+  function sourceActionsFor(
+    kind: SourceKind,
+    state: SourceState,
+  ): SourceEditorActions {
+    return {
+      get sourceEditing() {
+        return state.editing
+      },
+      get sourceSaving() {
+        return state.saving
+      },
+      get sourceDraft() {
+        return state.draft
+      },
+      onSourceEdit: () => {
+        // Prefill with the URL in effect, so 保存 is a no-op unless edited.
+        const report = store.report()
+        const source =
+          kind === 'runtime' ? normalizeSource(report?.runtime.source) : normalizeSource(report?.pluginSource)
+        state.draft = source?.url ?? ''
+        state.editing = true
+        render()
+      },
+      onSourceDraft: (value: string) => {
+        state.draft = value
+      },
+      onSourceSave: () => {
+        void submitSource(kind, state)
+      },
+      onSourceCancel: () => {
+        state.editing = false
+        render()
+      },
+      onSourceReset: () => {
+        void submitSource(kind, state, '')
+      },
+    }
+  }
+
+  /**
+   * Save one manifest source — or clear the override with an empty URL —
+   * then re-run discovery.
+   *
+   * The re-check is not optional: the report is cached, so without a fresh
+   * `POST /check` the facts and the update button would keep naming the OLD
+   * manifest's offer after the source changed. hq-edge answers 422 with a
+   * message meant for a person on refusal (bad scheme, credentials, …), which
+   * the toast shows verbatim.
+   */
+  async function submitSource(
+    kind: SourceKind,
+    state: SourceState,
+    url: string = state.draft,
+  ): Promise<void> {
+    state.saving = true
+    render()
+    const labels = kind === 'runtime' ? copy.runtime : copy.pluginSource
+    try {
+      if (kind === 'runtime') await setRuntimeUpdateSource(url)
+      else await setPluginUpdateSource(url)
+      state.editing = false
+      showToast(labels.saved, 'success')
+      try {
+        await checkUpdates()
+        await store.refresh()
+      } catch {
+        // The source IS saved; a failed re-check only leaves the previous
+        // offer on screen until the next refresh — the toolbar re-runs it.
+      }
+    } catch (err: unknown) {
+      showToast(
+        `${labels.saveFailed}: ${err instanceof Error ? err.message : String(err)}`,
+        'error',
+      )
+    } finally {
+      state.saving = false
+      render()
+    }
+  }
+
+  async function requestRuntime(): Promise<void> {
+    const version = runtimeLatestVersion(store.report()?.runtime)
+    if (version === null) {
+      showToast(copy.checkFailed, 'error')
+      return
+    }
+    runtimeArmed = false
+    runtimeBusy = true
+    render()
+    try {
+      const result = await requestRuntimeUpdate(version)
+      if (result?.error !== undefined) {
+        showToast(`${copy.installError}: ${result.error}`, 'error')
+        return
+      }
+      // 202 Accepted: hq-edge exits to let the EDA host swap the runtime and
+      // relaunch. This panel is about to go away with the restart, so say so —
+      // and latch it, so a store refresh cannot re-offer the button for a
+      // server that is already gone.
+      runtimeAccepted = true
+      showToast(copy.runtime.updateAccepted, 'success')
+    } catch (err: unknown) {
+      showToast(
+        `${copy.installError}: ${err instanceof Error ? err.message : String(err)}`,
+        'error',
+      )
+    } finally {
+      runtimeBusy = false
+      render()
+    }
+  }
+
   const render = (): void => {
     const report = store.report()
     const installing = store.installing()
@@ -579,7 +1083,8 @@ export function openUpdateView(store: UpdateStoreLike, copy: UpdateCopy): void {
     } else {
       renderList(listSection, report, copy, installing, store)
     }
-    renderRuntime(runtimeSection, report, copy)
+    renderPluginSource(pluginSourceSection, report, copy, pluginActions)
+    renderRuntime(runtimeSection, report, copy, runtimeActions)
     renderActions(actionBar, report, copy, store, installing)
   }