dsh-unlag 1.7.10 → 1.8.0

package/README.md

@@ -32,15 +32,14 @@ dsh plugin install dsh-unlag
 
 ## 不会丢什么
 
-- 轮次、子代理、终端进程：在宿主侧，一路继续。
+- 轮次、子代理、终端进程：照常继续。
 - 排队消息、输入草稿、附件：重建前先提交焦点里的内容；有人没存完就拦下，不硬刷。
 - 有未保存改动、开着弹窗、或下个页面要用的模块读不全：拦下并提示，宁可不刷。
 - 从不自己重启或退出 App。
 
 管不到（它会拦下并说明，不会硬来）：
 
-- 改动落在宿主侧的插件：新增原生能力、改服务声明、改权限。
-- 更新时正被某个任务使用的插件：那个任务可能随之结束。
+- 改动替插件加原生能力、改服务声明或权限：这类改动不在一次点击的范围里。
 - 独立进程和进程级的东西：宠物窗口自己的配置、DSH 自身升级、原生依赖变化。
 
 ## 排错
@@ -51,8 +50,5 @@ dsh plugin install dsh-unlag
 ## 测试
 
 ```sh
-node test/button.test.mjs
-node test/bundle-shim.test.mjs
-node test/client-guard.test.mjs
-node test/safety.test.mjs
+node --test test/*.test.mjs
 ```

package/client.js

@@ -6,8 +6,8 @@ window.__ModuleLoader__.load({
 
     const zh = /^zh/i.test(navigator.language || '');
     const COPY = zh
-      ? { label: '解除卡顿', hint: '卡顿时用：换掉插件代码并重建界面；运行中的任务、排队的消息保留', blocked: '暂时无法重建界面，稍后再试', unsaved: '有未保存的改动，先保存再重试', dialog: '先关闭打开的窗口再重载', queued: '已排队：任务跑完自动重载', failed: '插件更新没完成，稍后再按一次' } // ui-copy-ignore
-      : { label: 'Unlag', hint: 'For a sluggish interface: replaces plugin code and rebuilds the page; running turns and queued messages are kept', blocked: 'Cannot rebuild the page right now; try again', unsaved: 'Unsaved changes; save them, then retry', dialog: 'Close the open window first', queued: 'Queued; it reloads once the turn ends', failed: 'The plugin update did not finish; press again later' };
+      ? { label: '解除卡顿', hint: '卡顿时用：换掉插件代码并重建界面；运行中的任务、排队的消息保留', blocked: '暂时无法重建界面，稍后再试', unsaved: '有未保存的改动，先保存再重试', dialog: '先关闭打开的窗口再重载', queued: '更新已排队，稍后再按一次', applying: '还在应用这次更新，稍后再按一次', restart: '这次改动要重新打开应用才会生效', failed: '插件更新没完成，稍后再按一次' } // ui-copy-ignore
+      : { label: 'Unlag', hint: 'For a sluggish interface: replaces plugin code and rebuilds the page; running turns and queued messages are kept', blocked: 'Cannot rebuild the page right now; try again', unsaved: 'Unsaved changes; save them, then retry', dialog: 'Close the open window first', queued: 'Update queued; press again shortly', applying: 'Still applying this update; press again shortly', restart: 'This change needs the app reopened before it can apply', failed: 'The plugin update did not finish; press again later' };
 
     // Desktop shell only: the macOS and Windows desktop build owns the page and the running
     // app, so this is where the button belongs. A browser tab can reload freely on its own.
@@ -87,7 +87,10 @@ window.__ModuleLoader__.load({
     function reloadVerdict(data) {
       if (data === null || typeof data !== 'object') return 'failed';
       const status = typeof data.status === 'string' ? data.status : 'failed';
-      if (Array.isArray(data.pending) && data.pending.length > 0) return 'queued';
+      // A plugin that did not start makes the set unusable for a rebuild, whatever the status says.
+      if (Array.isArray(data.failedEntries) && data.failedEntries.length > 0) return 'failed';
+      // `pending` is not a queued update: the changed modules need a restart to load at all.
+      if (Array.isArray(data.pending) && data.pending.length > 0) return 'restart';
       if (typeof data.restartReason === 'string' && data.restartReason !== '') return 'failed';
       return status;
     }
@@ -149,8 +152,44 @@ window.__ModuleLoader__.load({
      * @param body - the served script.
      * @returns true when the body parses, or when this page cannot compile one at all.
      */
+    /** The source with comments and string contents blanked out, so a keyword scan sees code only. */
+    function codeOnly(source) {
+      let out = '';
+      let index = 0;
+      while (index < source.length) {
+        const here = source[index];
+        const next = source[index + 1];
+        if (here === '/' && next === '*') {
+          const end = source.indexOf('*/', index + 2);
+          index = end < 0 ? source.length : end + 2;
+          out += ' ';
+          continue;
+        }
+        if (here === '/' && next === '/') {
+          const end = source.indexOf('\n', index + 2);
+          index = end < 0 ? source.length : end;
+          continue;
+        }
+        if (here === '"' || here === "'" || here === '`') {
+          index += 1;
+          while (index < source.length && source[index] !== here) {
+            if (source[index] === '\\') index += 1;
+            index += 1;
+          }
+          index += 1;
+          out += '""';
+          continue;
+        }
+        out += here;
+        index += 1;
+      }
+      return out;
+    }
+
     function parsesAsClassicScript(body) {
       try {
+        // A top-level return parses in a function body but not as a classic script.
+        if (/(?:^|[;{}])\s*return\b/u.test(codeOnly(body))) return false;
         new Function(body); // eslint-disable-line no-new-func
         return true;
       } catch (error) {
@@ -213,7 +252,10 @@ window.__ModuleLoader__.load({
       }
       if (scripts.length === 0) return false;
       const live = await hostBootGraph();
-      if (live !== null && frozen !== null) {
+      if (frozen !== null) {
+        // The frozen list decides what this document boots. Without the current graph there is
+        // nothing to prove that list still resolves, so the page is not rebuilt.
+        if (live === null) return false;
         const liveIds = new Set((Array.isArray(live.entries) ? live.entries : []).map((entry) => (typeof entry === 'string' ? entry : entry?.id)));
         const kept = Array.isArray(frozen.entries) ? frozen.entries : [];
         for (const entry of kept) {
@@ -480,7 +522,16 @@ window.__ModuleLoader__.load({
         if (replace) {
           const status = await replacePlugins();
           if (status !== 'done' && status !== 'off') {
-            const key = status === 'queued' ? 'queued' : status === 'unavailable' ? 'blocked' : 'failed';
+            const key =
+              status === 'queued'
+                ? 'queued'
+                : status === 'applying'
+                  ? 'applying'
+                  : status === 'restart'
+                    ? 'restart'
+                    : status === 'unavailable'
+                      ? 'blocked'
+                      : 'failed';
             report('plugin-held', key);
             return stop(key);
           }

package/index.js

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from 'node:async_hooks'
 import { appendFileSync, existsSync, readFileSync, statSync, watch } from 'node:fs'
 import { homedir } from 'node:os'
 import { join, resolve } from 'node:path'
@@ -29,6 +30,7 @@ export const inject = ['webServer']
 /** A transaction that has not finished in this long is stuck; the press reports it instead of hanging. */
 const RELOAD_TIMEOUT_MS = 20_000
 
+
 const LOG_PATH = join(homedir(), '.dsh', 'unlag-reload.log')
 /** Tests point this at a scratch file, so a test run leaves the live log readable. */
 const logTarget = () => process.env.DSH_UNLAG_LOG ?? LOG_PATH
@@ -147,6 +149,18 @@ function worthReloading(filename) {
  * The plugin half. One controller serves both callers: a saved file (debounced) and the header
  * button (immediate). A swap never waits for turns, never interrupts them, and never re-enters.
  */
+/**
+ * The service keeps its transaction context in an AsyncLocalStorage on the instance. Resolve it by
+ * type as well as by name, so a renamed field still works; the name stays the fast path.
+ */
+function transactionContext(service) {
+  try {
+    if (typeof service?.executing?.exit === 'function') return service.executing
+    for (const value of Object.values(service ?? {})) if (value instanceof AsyncLocalStorage) return value
+  } catch {}
+  return null
+}
+
 function pluginReloader(ctx, config) {
   /** HMR can start after this half, so ask per use instead of once at load. */
   const hmrService = () => {
@@ -161,6 +175,8 @@ function pluginReloader(ctx, config) {
 
   let timer = null
   let running = false
+  /** The queue request this plugin is still waiting on, so a timeout is not reported as a cancel. */
+  let work = null
   let again = false
   let deferrals = 0
   let lastRun = 0
@@ -192,35 +208,64 @@ function pluginReloader(ctx, config) {
      * that context first is what the service's own watcher does, and it keeps the request queued
      * instead of running a second recomposition beside the first.
      */
+    const context = transactionContext(hmr)
     const ask = (service) =>
-      typeof service.executing?.exit === 'function'
-        ? service.executing.exit(() => service.runExclusive(() => service.reconcileProfile([])))
-        : service.runExclusive(() => service.reconcileProfile([]))
+      context === null
+        ? service.runExclusive(() => service.reconcileProfile([]))
+        : context.exit(() => service.runExclusive(() => service.reconcileProfile([])))
     const abandoned = () =>
       new Promise((_resolve, reject) => {
         const limit = Number(process.env.DSH_UNLAG_TIMEOUT_MS ?? '') || RELOAD_TIMEOUT_MS
         const timer = setTimeout(() => reject(new Error('the plugin update did not finish in time')), limit)
         timer.unref?.()
       })
+    /**
+     * The queue request itself keeps running after this plugin stops waiting for it. It is tracked
+     * so a timeout is reported as still applying, never as a failed update that later fires anyway.
+     */
+    const tracked = (request) => {
+      work = request
+      const settle = () => {
+        if (work === request) work = null
+      }
+      request.then(settle, settle)
+      return request
+    }
     let result = null
     for (let attempt = 0; ; attempt += 1) {
       try {
-        result = await Promise.race([ask(hmr), abandoned()])
+        result = await Promise.race([tracked(ask(hmr)), abandoned()])
         break
       } catch (error) {
         const message = String(error?.message ?? error)
-        if (message.includes('nested') === false) throw error
-        if (attempt >= 9) throw error
-        await new Promise((resolve) => setTimeout(resolve, 250 * (attempt + 1)))
+        if (message.includes('nested')) {
+          if (attempt >= 9) throw error
+          const step = Number(process.env.DSH_UNLAG_RETRY_MS ?? '') || 250
+          await new Promise((resolve) => setTimeout(resolve, step * (attempt + 1)))
+          continue
+        }
+        if (message.includes('did not finish in time')) {
+          error.stillRunning = work !== null
+          throw error
+        }
+        throw error
       }
     }
     const warnings = Array.isArray(result?.warnings) ? result.warnings : []
     const pending = Array.isArray(result?.pending) ? result.pending : []
     const restartReason = typeof result?.restartReason === 'string' ? result.restartReason : null
+    /**
+     * A reconciliation that returns without throwing can still have left a plugin unloaded: the app
+     * reports that as a warning. A set with an entry that did not start is not a set the page can be
+     * rebuilt against, so the press is reported as failed and names what did not start.
+     */
+    const failedEntries = warnings
+      .map((warning) => (typeof warning === 'string' ? warning : String(warning?.message ?? '')))
+      .filter((warning) => /fail|cannot|missing|invalid|error/iu.test(warning))
     log(
       `plugins reloaded (warnings=${warnings.length} pending=${pending.length}${restartReason === null ? '' : ` restart=${restartReason}`})`,
     )
-    return { status: 'done', warnings, pending, restartReason }
+    return { status: 'done', warnings, pending, restartReason, failedEntries }
   }
 
   const flush = async () => {
@@ -304,8 +349,12 @@ function pluginReloader(ctx, config) {
     warnings: [],
     pending: [],
     restartReason: null,
+    failedEntries: [],
   })
 
+  /** A press made while an update is still running joins that update instead of queueing another. */
+  const busyAnswer = () => (work !== null ? { status: 'applying', warnings: [], pending: [], restartReason: null, failedEntries: [] } : queuedAnswer(queueReload()))
+
   /**
    * The button path: run now and report what happened, so the page can tell the user why the
    * press did not replace anything instead of looking broken.
@@ -313,12 +362,12 @@ function pluginReloader(ctx, config) {
    */
   const reloadNow = async (force = false) => {
     const hmr = hmrService()
-    if (hmr === null) return { status: 'unavailable', warnings: [], pending: [], restartReason: null }
+    if (hmr === null) return { status: 'unavailable', warnings: [], pending: [], restartReason: null, failedEntries: [] }
     if (turnsRunning()) log('reloading while turns are still running; they keep running')
-    if (running || (force === false && busy())) return queuedAnswer(queueReload())
+    if (running || (force === false && busy())) return busyAnswer()
     const wait = lastRun + MIN_INTERVAL_MS - Date.now()
     if (wait > 0) await new Promise((resolve) => setTimeout(resolve, Math.min(wait, 2000)))
-    if (running || (force === false && busy())) return queuedAnswer(queueReload())
+    if (running || (force === false && busy())) return busyAnswer()
     if (timer !== null) {
       clearTimeout(timer)
       timer = null
@@ -328,18 +377,53 @@ function pluginReloader(ctx, config) {
     lastRun = Date.now()
     try {
       const outcome = await reload(hmr)
+      /**
+       * `pending` means the changed modules are not loaded yet and need a restart this plugin does
+       * not perform; it is not a queued update that finishes on its own.
+       */
       if (outcome.pending.length > 0 || outcome.restartReason !== null) {
         // The app accepted the update but has not finished starting the new plugin set. Rebuilding
         // the page now would start a document against a set that is still settling.
-        return { status: 'failed', warnings: outcome.warnings, pending: outcome.pending, restartReason: outcome.restartReason }
+        return {
+          status: 'failed',
+          warnings: outcome.warnings,
+          pending: outcome.pending,
+          restartReason: outcome.restartReason,
+          failedEntries: outcome.failedEntries,
+        }
+      }
+      if (outcome.failedEntries.length > 0) {
+        return {
+          status: 'failed',
+          warnings: outcome.warnings,
+          pending: [],
+          restartReason: null,
+          failedEntries: outcome.failedEntries,
+        }
       }
       return outcome
     } catch (error) {
+      if (error?.stillRunning === true) {
+        // The queue still holds the request: it may yet apply, so the press is not called failed.
+        return { status: 'applying', warnings: [], pending: [], restartReason: null, failedEntries: [] }
+      }
       log(`reload did not finish; the plugin set may be partly applied: ${error?.message ?? error}`)
-      return { status: 'failed', warnings: [], pending: [], restartReason: null }
+      return { status: 'failed', warnings: [], pending: [], restartReason: null, failedEntries: [] }
     } finally {
-      running = false
-      again = false
+      if (work === null) {
+        running = false
+        again = false
+      } else {
+        // Stay busy until the queue request really settles, so a second press joins it.
+        const release = () => {
+          running = false
+          if (again) {
+            again = false
+            if (timer === null) timer = setTimeout(() => void flush(), debounce)
+          }
+        }
+        work.then(release, release)
+      }
     }
   }
 
@@ -398,10 +482,22 @@ function sendJson(res, status, payload) {
  * leaves it naming a module graph that no longer resolves, which is exactly the list a rebuild
  * must not trust.
  */
-function liveBootGraph(server) {
+function liveBootGraph(ctx) {
   try {
-    if (typeof server.collectIndexInjections !== 'function') return null
-    const rows = server.collectIndexInjections()
+    /**
+     * The module table's own graph is the list the next document is built from, and reading it has
+     * no side effects. The injection table needs a peer for anything page-scoped, so it is not a
+     * substitute: a graph that cannot be read stays null and the page holds instead of guessing.
+     */
+    const modules = ctx.get('clientModules')
+    if (typeof modules?.graph === 'function') {
+      const graph = modules.graph()
+      if (graph !== null && typeof graph === 'object' && Array.isArray(graph.entries)) return graph
+      return null
+    }
+    const server = ctx.get('webServer')
+    if (typeof server?.collectIndexInjections !== 'function') return null
+    const rows = server.collectIndexInjections({})
     if (!Array.isArray(rows)) return null
     for (const row of rows) {
       if (row?.kind !== 'global') continue
@@ -501,8 +597,11 @@ async function fetchBundleAt(clientModules, url, method) {
 async function currentBundleAnswer(clientModules, method, url) {
   const request = bundleRequest(url)
   if (request === null) return null
-  const urls = currentBundleUrls(clientModules.graph(), request)
+  const graph = clientModules.graph()
+  const urls = currentBundleUrls(graph, request)
   if (urls.length === 0) return null
+  // A request already at the generation the table serves is the table's to answer.
+  if (typeof graph?.rev === 'string' && graph.rev !== '' && request.rev === graph.rev) return null
   if (request.rev !== '' && urls.some((target) => target.endsWith(`&rev=${request.rev}`))) return null
   for (const target of urls) {
     const response = await fetchBundleAt(clientModules, target, 'GET')
@@ -541,6 +640,29 @@ async function serveCurrentBundle(clientModules, req, res) {
   }
 }
 
+/** The revision the module table serves now, or null when it cannot be read. */
+function currentRevision(clientModules) {
+  try {
+    const graph = clientModules.graph()
+    return typeof graph?.rev === 'string' && graph.rev !== '' ? graph.rev : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Point a bundle request at the current revision while keeping the plugin set it names. The table
+ * only keeps the previous generation of whole documents, and dynamic chunks are served at the
+ * current revision alone; a page that kept an old revision would get a main bundle it cannot load
+ * chunks for. Rewriting the revision keeps one generation in the whole answer.
+ */
+function retargetRevision(url, current) {
+  if (current === null || typeof url !== 'string') return null
+  const match = /([?&])rev=([^&#]*)/u.exec(url)
+  if (match === null || match[2] === current) return null
+  return `${url.slice(0, match.index)}${match[1]}rev=${current}${url.slice(match.index + match[0].length)}`
+}
+
 /** The same answer over the request-in/response-out route a newer app registers. */
 async function serveCurrentBundleResource(clientModules, request) {
   try {
@@ -580,13 +702,36 @@ function serveBundlesAtCurrentRevision(ctx) {
   if (typeof route.resource === 'function') {
     const original = route.resource
     const wrapped = async (request) => {
+      /**
+       * The table's own answer comes first: it still holds the document generation this page booted
+       * from. Only when it has nothing is the current one served, and the request is retargeted at
+       * the current revision so the answer and its chunks belong to the same generation.
+       */
+      const retargeted = retargetRevision(String(request?.url ?? ''), currentRevision(clientModules))
+      const method = String(request?.method ?? 'GET').toUpperCase()
+      let answer = null
+      try {
+        answer = await original(request)
+      } catch (error) {
+        log(`cannot answer a bundle request: ${error?.message ?? error}`)
+      }
+      if (retargeted !== null && (answer === null || answer === undefined || answer.status === 404)) {
+        try {
+          const next = method === 'GET' || method === 'HEAD' ? new Request(retargeted, { method, headers: request.headers }) : request
+          const second = await original(next)
+          if (second !== null && second !== undefined) answer = second
+        } catch (error) {
+          log(`cannot answer a bundle request: ${error?.message ?? error}`)
+        }
+      }
+      if (answer !== null && answer !== undefined && answer.status !== 404) return answer
       try {
         const served = await serveCurrentBundleResource(clientModules, request)
         if (served !== null) return served
       } catch (error) {
         log(`cannot answer a bundle request: ${error?.message ?? error}`)
       }
-      return original(request)
+      return answer
     }
     route[SHIM_MARK] = true
     route.resource = wrapped
@@ -595,14 +740,82 @@ function serveBundlesAtCurrentRevision(ctx) {
   }
   if (typeof route.handler !== 'function') return null
   const original = route.handler
-  const wrapped = (req, res) => {
-    const fallback = () => original(req, res)
-    const answered = serveCurrentBundle(clientModules, req, res).catch((error) => {
+  /**
+   * The table's own answer is kept, and only a 404 is held back long enough to ask whether the
+   * current generation can answer instead; the plugin set is retargeted at the current revision
+   * first, so the served document and the chunks it later asks for are one generation.
+   */
+  const wrapped = async (req, res) => {
+    const originalUrl = String(req?.url ?? '')
+    const retargeted = retargetRevision(originalUrl, currentRevision(clientModules))
+    const realWriteHead = res.writeHead
+    const realEnd = res.end
+    const ask = async (url) => {
+      let held = null
+      let body
+      if (url !== originalUrl) {
+        try {
+          req.url = url
+        } catch {
+          /* a frozen request keeps its own address */
+        }
+      }
+      if (typeof realWriteHead === 'function') {
+        res.writeHead = (status, ...rest) => {
+          if (status === 404) {
+            held = { status, headers: rest[0] }
+            return res
+          }
+          return realWriteHead.call(res, status, ...rest)
+        }
+      }
+      if (typeof realEnd === 'function') {
+        res.end = (...args) => {
+          if (held !== null) {
+            body = typeof args[0] === 'string' || Buffer.isBuffer(args[0]) ? args[0] : ''
+            return res
+          }
+          return realEnd.apply(res, args)
+        }
+      }
+      try {
+        await Promise.resolve(original(req, res))
+      } catch (error) {
+        log(`cannot answer a bundle request: ${error?.message ?? error}`)
+      } finally {
+        try {
+          res.writeHead = realWriteHead
+          res.end = realEnd
+        } catch {
+          /* the response object owns its own shape */
+        }
+      }
+      return { held, body }
+    }
+    // The table's own answer first: it still holds the generation this page booted from.
+    let outcome = await ask(originalUrl)
+    if (outcome.held !== null && retargeted !== null) outcome = await ask(retargeted)
+    if (outcome.held === null) return undefined
+    // The shim resolves the set from the address the page asked for, not the retried one.
+    try {
+      req.url = originalUrl
+    } catch {
+      /* a frozen request keeps its own address */
+    }
+    let served = false
+    try {
+      served = await serveCurrentBundle(clientModules, req, res)
+    } catch (error) {
       log(`cannot answer a bundle request: ${error?.message ?? error}`)
-      return false
-    })
-    if (typeof answered?.then !== 'function') return fallback()
-    return answered.then((served) => (served === true ? undefined : fallback()))
+    }
+    if (served === true) return undefined
+    try {
+      realWriteHead.call(res, outcome.held.status, outcome.held.headers)
+      realEnd.call(res, outcome.body)
+    } catch {
+      /* the response is gone; nothing left to answer */
+    }
+    return undefined
   }
   route[SHIM_MARK] = true
   route.handler = wrapped
@@ -677,7 +890,7 @@ function serveButton(ctx, controller, config) {
       `${BASE_PATH}/graph`,
       (_req, res) => {
         ensureBundleShim(ctx)
-        sendJson(res, 200, { graph: liveBootGraph(server) })
+        sendJson(res, 200, { graph: liveBootGraph(ctx) })
       },
     ],
     [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-unlag",
-  "version": "1.7.10",
+  "version": "1.8.0",
   "type": "module",
   "description": "One press applies plugin edits right away and brings a laggy interface back; running turns, queued messages and unsent input are untouched, and nothing restarts.",
   "license": "MIT",