dsh-human-wait 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.2.1 — 2026-10-27
+
+- Adds a browser half (`client.js`), so the plugin gets its own settings page under **Plugins**:
+  a wait-cap field with 1 h / 24 h / unlimited quick values, an "overridden" chip and a
+  "restore default" action.
+- `enabled` and `humanWaitCapMs` are now volatile: they are re-read while the plugin runs, so a
+  save applies in about 1.5 s without restarting DSH. The wrappers also check `enabled` on
+  every call, so turning the plugin off through the patch takes effect immediately.
+- The host half takes over the settings page (`settings.configure({ auto: false })`) instead of
+  letting DSH auto-generate a second, schema-only one.
+- Tests: adds `test/client.test.mjs` (bundle id, slot key, page and summary rendering) and two
+  runtime cases for re-reading the settings.
+
+## 0.1.1 — 2026-10-26
+
+First release published by GitHub Actions with npm provenance (trusted publishing).
+
+- No behaviour change from 0.1.0; the source is the same apart from this entry and the docs.
+- README: installing from the registry is now the primary route, the tarball route moved to the
+  fallback slot.
+
 ## 0.1.0 — 2026-10-26
 
 First release.

package/README.md

@@ -42,15 +42,20 @@ execution budget and is what the plugin enforces.
 
 ## Install
 
-The plugin is a normal DSH bundle (one inserted host row, no client half). Pick one route:
+The plugin is a normal DSH bundle: one inserted host row, plus a browser half that renders the
+settings page under **Plugins**. Pick one route:
 
-**A. From a tarball, by hand.** In `<DSH_HOME>/profiles/<profile>/package.json` add the dependency
+**A. From the registry (recommended).** Use the Plugins settings page, or a
+`plugin_manager install_bundle` call in a session, with the spec `dsh-human-wait@0.2.1`; the
+plugin manager adds both the dependency and the bundle entry for you.
+
+**B. From a tarball, by hand.** In `<DSH_HOME>/profiles/<profile>/package.json` add the dependency
 and the bundle name, then install it:
 
 ```jsonc
 {
   "dependencies": {
-    "dsh-human-wait": "file:D:/path/to/dsh-human-wait-0.1.0.tgz"
+    "dsh-human-wait": "file:D:/path/to/dsh-human-wait-0.2.1.tgz"
   },
   "dsh": { "profile": { "bundles": ["dsh-human-wait"] } }
 }
@@ -61,10 +66,6 @@ and the bundle name, then install it:
 & "$env:USERPROFILE\.dsh\dsh-runtimes\dsh-primary-runtime\dependencies\pnpm\pnpm.cjs" install --dir "$env:USERPROFILE\.dsh\profiles\desktop"
 ```
 
-**B. From the registry, once published.** Use the Plugins settings page (or a
-`plugin_manager install_bundle` call in a session) with the spec `dsh-human-wait@0.1.0`; the
-plugin manager adds both the dependency and the bundle entry for you.
-
 Then **quit DSH from the tray icon and start it again** — bundles are composed at boot. The
 Electron-managed profile cannot be booted through the `dsh` CLI (`profile "desktop" is managed
 exclusively by the Electron application`), so restarting the app is the only way to apply it.
@@ -93,7 +94,24 @@ How the clock works: the plugin re-arms a single timer on every accounting event
 wait starting or ending, or the timer itself firing), so there is no fixed sampling period and
 no configuration knob for one.
 
-Changes are read when the plugin loads, so restart DSH after editing.
+Both options are **volatile**: they are read again while the plugin is running, so a change
+takes effect within about a second and a half, with no restart. Editing the
+patch by hand is still read at boot.
+
+## Settings page
+
+The plugin ships a browser half, so it gets its own card on its page under **Plugins** (the same
+place as Team limits):
+
+- a number field for `humanWaitCapMs`, with quick buttons for 1 hour / 24 hours / unlimited;
+- an "overridden" chip and a "restore default" action for that field;
+- a one-line summary on the card itself.
+
+`enabled` stays in the patch layer (`cordis.patch.yml`), where it is read live within about a
+second and a half.
+
+The values are written back to this profile's patch layer through the normal settings path;
+uninstalling the plugin does not roll them back.
 
 ## What counts as a human wait
 

package/client.js

@@ -0,0 +1,363 @@
+window.__ModuleLoader__.load({
+  id: 'dsh-human-wait',
+  factory: (require) => {
+    var module = { exports: {} }
+    var exports = module.exports
+
+    var React = require('react')
+    var h = React.createElement
+
+    var NS = 'human-wait'
+
+    var DEFAULTS = {
+      humanWaitCapMs: 86400000,
+    }
+
+    var HOUR = 3600000
+
+    var QUICK_CAPS = [
+      { value: HOUR, zh: '1 小时', en: '1 hour' },
+      { value: 24 * HOUR, zh: '24 小时', en: '24 hours' },
+      { value: -1, zh: '无限', en: 'Unlimited' },
+    ]
+
+    function isZh() {
+      try {
+        return (navigator.language || '').toLowerCase().indexOf('zh') === 0
+      } catch (error) {
+        return false
+      }
+    }
+
+    var COPY = {
+      capLabel: ['等待上限（毫秒）', 'Wait cap (ms)'],
+      capHelp: [
+        '一次运行最多在等待人上花多久。-1 表示不设上限。',
+        'How long one run may spend waiting for a human. -1 means no cap.',
+      ],
+      overridden: ['已覆盖', 'Overridden'],
+      reset: ['恢复默认', 'Restore default'],
+      loading: ['正在读取配置…', 'Loading configuration…'],
+      unavailable: [
+        '当前连接不支持写入设置，这一页只能查看。',
+        'This connection cannot write settings, so this page is read-only.',
+      ],
+      saveFailed: ['保存失败：', 'Save failed: '],
+      note: [
+        '数值保存在当前 profile 的补丁层；卸载本插件不会自动撤回。',
+        'Values persist in this profile patch layer; uninstalling the plugin does not roll them back.',
+      ],
+    }
+
+    function t(key) {
+      var pair = COPY[key]
+      if (pair === undefined) return key
+      return isZh() ? pair[0] : pair[1]
+    }
+
+    var CSS = [
+      '.dhw { display: flex; flex-direction: column; gap: 26px; max-width: 820px; padding: 4px 2px 8px; }',
+      '.dhw-group { display: flex; flex-direction: column; gap: 14px; }',
+      '.dhw-group-title { font-size: 14.5px; font-weight: 600; margin: 0; line-height: 1.4; }',
+      '.dhw-cell { display: flex; flex-direction: column; gap: 8px; min-width: 0; }',
+      '.dhw-labelrow { display: flex; align-items: center; gap: 8px; min-height: 20px; }',
+      '.dhw-label { font-size: 13px; font-weight: 500; }',
+      '.dhw-chip { font-size: 11.5px; line-height: 18px; padding: 0 8px; border-radius: 999px; background: rgba(128,128,128,.14); opacity: .8; }',
+      '.dhw-spacer { flex: 1 1 auto; }',
+      '.dhw-reset { font-size: 12.5px; color: inherit; opacity: .55; background: none; border: none; padding: 0; cursor: pointer; }',
+      '.dhw-reset:hover:not(:disabled) { opacity: .85; text-decoration: underline; }',
+      '.dhw-reset:disabled { opacity: .25; cursor: default; }',
+      '.dhw-input { width: 100%; box-sizing: border-box; height: 38px; padding: 0 12px; font-size: 13.5px; font-variant-numeric: tabular-nums; border-radius: 9px; border: 1px solid rgba(128,128,128,.36); background: transparent; color: inherit; outline: none; }',
+      '.dhw-input:focus { border-color: rgba(76,139,245,.85); }',
+      '.dhw-input:disabled { opacity: .45; }',
+      '.dhw-quick { display: flex; flex-wrap: wrap; gap: 8px; }',
+      '.dhw-quickbtn { font-size: 12.5px; padding: 5px 11px; border-radius: 999px; border: 1px solid rgba(128,128,128,.36); background: transparent; color: inherit; cursor: pointer; }',
+      '.dhw-quickbtn:hover:not(:disabled) { border-color: rgba(76,139,245,.7); }',
+      '.dhw-quickbtn:disabled { opacity: .4; cursor: default; }',
+      '.dhw-help { font-size: 12px; opacity: .5; line-height: 1.5; }',
+      '.dhw-foot { font-size: 12px; opacity: .48; line-height: 1.6; margin: 0; max-width: 64ch; }',
+      '.dhw-error { font-size: 12.5px; color: #d9534f; }',
+      '.dhw-summary { font-size: 13px; opacity: .78; font-variant-numeric: tabular-nums; }',
+    ].join('\n')
+
+    /** Unwrap a volatile ref if the host handed one through. */
+    function unwrap(value) {
+      if (value !== null && typeof value === 'object') {
+        if (typeof value.get === 'function') return value.get()
+        if (typeof value.value !== 'undefined') return value.value
+      }
+      return value
+    }
+
+    function capOf(value, fallback) {
+      var raw = unwrap(value)
+      if (raw === -1) return -1
+      var parsed = typeof raw === 'number' ? raw : Number(raw)
+      return Number.isFinite(parsed) && parsed >= 1 ? Math.floor(parsed) : fallback
+    }
+
+    function valuesOf(source) {
+      var bag = source !== null && typeof source === 'object' ? source : {}
+      return {
+        humanWaitCapMs: capOf(bag.humanWaitCapMs, DEFAULTS.humanWaitCapMs),
+      }
+    }
+
+    function formatCap(ms) {
+      if (ms === -1) return isZh() ? '无限' : 'unlimited'
+      if (ms % HOUR === 0) {
+        var hours = ms / HOUR
+        return isZh() ? hours + ' 小时' : hours + (hours === 1 ? ' hour' : ' hours')
+      }
+      return ms + ' ms'
+    }
+
+    function HumanWaitPage(props) {
+      var form = props.configForm || props.form
+      var summary = props.view === 'summary'
+
+      if (!form) {
+        return h('p', { className: 'dhw-foot' }, t('loading'))
+      }
+
+      var snapshotPair = React.useState(function () {
+        return form.getSnapshot()
+      })
+      var snapshot = snapshotPair[0]
+      var setSnapshot = snapshotPair[1]
+
+      var draftPair = React.useState(function () {
+        return valuesOf(snapshot.value)
+      })
+      var draft = draftPair[0]
+      var setDraft = draftPair[1]
+
+      var errorPair = React.useState('')
+      var error = errorPair[0]
+      var setError = errorPair[1]
+
+      var pendingPair = React.useState({})
+      var pending = pendingPair[0]
+      var setPending = pendingPair[1]
+
+      React.useEffect(function () {
+        var off = form.subscribe(function () {
+          setSnapshot(form.getSnapshot())
+        })
+        setSnapshot(form.getSnapshot())
+        return off
+      }, [form])
+
+      React.useEffect(function () {
+        var next = valuesOf(snapshot.value)
+        var keys = Object.keys(pending)
+        setDraft(function (previous) {
+          var merged = {}
+          for (var name in previous) merged[name] = previous[name]
+          for (var name in next) {
+            if (keys.indexOf(name) < 0) merged[name] = next[name]
+          }
+          return merged
+        })
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+      }, [snapshot.value])
+
+      React.useEffect(function () {
+        var keys = Object.keys(pending)
+        if (keys.length === 0) return undefined
+        var timer = setTimeout(function () {
+          var chain = Promise.resolve()
+          keys.forEach(function (key) {
+            chain = chain.then(function () {
+              return form.set(key, pending[key])
+            })
+          })
+          chain
+            .then(function () {
+              setPending({})
+            })
+            .catch(function (caught) {
+              setPending({})
+              setError(t('saveFailed') + String((caught && caught.message) || caught))
+            })
+        }, 700)
+        return function () {
+          clearTimeout(timer)
+        }
+      }, [pending, form])
+
+      var ready = snapshot.status === 'ready'
+      var disabled = !ready
+
+      function write(key, value) {
+        setError('')
+        setPending(function (previous) {
+          var next = {}
+          for (var name in previous) next[name] = previous[name]
+          next[key] = value
+          return next
+        })
+      }
+
+      function onCapInput(raw) {
+        if (raw === '' || raw === '-') {
+          setDraft(function (previous) {
+            var merged = {}
+            for (var name in previous) merged[name] = previous[name]
+            merged.humanWaitCapMs = raw === '-' ? -1 : DEFAULTS.humanWaitCapMs
+            return merged
+          })
+          return
+        }
+        var parsed = Number(raw)
+        if (!Number.isFinite(parsed)) return
+        var safe = parsed === -1 ? -1 : Math.max(1, Math.floor(parsed))
+        setDraft(function (previous) {
+          var merged = {}
+          for (var name in previous) merged[name] = previous[name]
+          merged.humanWaitCapMs = safe
+          return merged
+        })
+        write('humanWaitCapMs', safe)
+      }
+
+      function onQuick(value) {
+        setDraft(function (previous) {
+          var merged = {}
+          for (var name in previous) merged[name] = previous[name]
+          merged.humanWaitCapMs = value
+          return merged
+        })
+        write('humanWaitCapMs', value)
+      }
+
+      function onReset(key) {
+        setDraft(function (previous) {
+          var merged = {}
+          for (var name in previous) merged[name] = previous[name]
+          merged[key] = DEFAULTS[key]
+          return merged
+        })
+        write(key, DEFAULTS[key])
+      }
+
+      if (summary) {
+        return h('span', { className: 'dhw-summary' }, formatCap(draft.humanWaitCapMs))
+      }
+
+      var capOverridden = draft.humanWaitCapMs !== DEFAULTS.humanWaitCapMs
+
+      var capGroup = h(
+        'section',
+        { className: 'dhw-group', key: 'cap' },
+        h('h3', { className: 'dhw-group-title' }, isZh() ? '等待上限' : 'Wait cap'),
+        h(
+          'div',
+          { className: 'dhw-cell' },
+          h(
+            'div',
+            { className: 'dhw-labelrow' },
+            h('label', { className: 'dhw-label', htmlFor: 'dhw-cap' }, t('capLabel')),
+            capOverridden ? h('span', { className: 'dhw-chip' }, t('overridden')) : null,
+            h('span', { className: 'dhw-spacer' }),
+            capOverridden
+              ? h(
+                  'button',
+                  {
+                    type: 'button',
+                    className: 'dhw-reset',
+                    disabled: disabled,
+                    onClick: function () {
+                      onReset('humanWaitCapMs')
+                    },
+                  },
+                  t('reset'),
+                )
+              : null,
+          ),
+          h('input', {
+            id: 'dhw-cap',
+            className: 'dhw-input',
+            type: 'number',
+            min: -1,
+            step: 1,
+            inputMode: 'numeric',
+            disabled: disabled,
+            value: String(draft.humanWaitCapMs),
+            onChange: function (event) {
+              onCapInput(event.target.value)
+            },
+          }),
+          h(
+            'div',
+            { className: 'dhw-quick' },
+            QUICK_CAPS.map(function (item) {
+              return h(
+                'button',
+                {
+                  type: 'button',
+                  className: 'dhw-quickbtn',
+                  key: item.value,
+                  disabled: disabled,
+                  onClick: function () {
+                    onQuick(item.value)
+                  },
+                },
+                isZh() ? item.zh : item.en,
+              )
+            }),
+          ),
+          h('span', { className: 'dhw-help' }, t('capHelp')),
+        ),
+      )
+
+      return h(
+        'div',
+        { className: 'dhw' },
+        h('style', null, CSS),
+        ready ? null : h('p', { className: 'dhw-foot' }, t(snapshot.status === 'unavailable' ? 'unavailable' : 'loading')),
+        capGroup,
+        error ? h('p', { className: 'dhw-error' }, error) : null,
+        h('p', { className: 'dhw-foot' }, t('note')),
+      )
+    }
+
+    function apply(ctx) {
+      try {
+        var forms = ctx.configForms
+        var form = forms ? forms.get(NS) : null
+        if (!form) {
+          console.error('[human-wait] configForms service is unavailable; no settings page is registered')
+          return
+        }
+        ctx.effect(
+          function () {
+            return forms.whileServed([NS], function () {
+              return ctx.slots.inject('plugins.bundle.config', function () {
+                return ctx.slots.register(
+                  {
+                    name: 'plugins.bundle.config',
+                    key: 'dsh-human-wait',
+                    inject: function () {
+                      return { configForm: form }
+                    },
+                  },
+                  HumanWaitPage,
+                )
+              })
+            })
+          },
+          'human-wait: bundle config',
+        )
+      } catch (error) {
+        console.error('[human-wait] client half failed to mount: ' + String((error && error.message) || error))
+      }
+    }
+
+    exports.name = 'dsh-human-wait'
+    exports.inject = ['slots', 'configForms']
+    exports.apply = apply
+
+    return module.exports
+  },
+})

package/cordis.patch.yml

@@ -17,6 +17,12 @@
 # `timeoutMs` passed to a single `run_code` call) is still honoured for the
 # time the program actually spends executing: the plugin re-arms the deadline
 # on every accounting event, so it does not resample on a timer.
+#
+# Both options are volatile and re-read while the plugin runs, so the wait cap
+# saved from the plugin's page under Settings → Plugins takes effect within
+# about 1.5 s; `enabled` is read from here (patch edits also apply live). The
+# browser half (`client.js`, declared by `dsh.client`) renders that page; this
+# file stays free of user values.
 - insert:
     - id: human-wait
       name: 'dsh-human-wait'

package/index.js

@@ -35,6 +35,9 @@ const DEFAULT_HUMAN_WAIT_CAP_MS = 24 * 60 * 60 * 1000
 const MAX_TIMER_MS = 2_147_483_647
 const DEADLINE_MESSAGE = 'execution deadline reached'
 
+/** How often the live settings are compared against the volatile Config refs. */
+const POLL_INTERVAL_MS = 1500
+
 /** Per-run wait accounting; a run has a slot only while it is on the stack. */
 const runScope = new AsyncLocalStorage()
 
@@ -51,9 +54,9 @@ try {
 export const Config = Schema === undefined
   ? undefined
   : Schema.object({
-    enabled: Schema.boolean().default(true)
+    enabled: Schema.boolean().default(true).volatile()
       .description('Pause the PTC run deadline while a human-interaction wait is pending.'),
-    humanWaitCapMs: Schema.number().default(DEFAULT_HUMAN_WAIT_CAP_MS)
+    humanWaitCapMs: Schema.number().default(DEFAULT_HUMAN_WAIT_CAP_MS).volatile()
       .description('Longest time a run may spend waiting for a human, in milliseconds. -1 removes the cap.'),
   })
 
@@ -195,9 +198,10 @@ function enterHumanWait() {
  * Wrap one asynchronous method so callers' time is not charged to the run.
  * @param {object} host
  * @param {string} key
+ * @param {{ enabled: boolean }} live
  * @param {object} logger
  */
-function patchWaitMethod(host, key, logger) {
+function patchWaitMethod(host, key, live, logger) {
   const holder = methodHolder(host, key)
   if (holder === undefined) return undefined
 
@@ -205,6 +209,7 @@ function patchWaitMethod(host, key, logger) {
   if (isPatched(original)) return undefined
 
   const wrapped = function patchedHumanWait(...args) {
+    if (!live.enabled) return Reflect.apply(original, this, args)
     const leave = enterHumanWait()
     let result
     try {
@@ -246,10 +251,10 @@ function patchWaitMethod(host, key, logger) {
  * Wrap the run method: the runtime keeps its compile/validation, the deadline
  * moves into this plugin so it can be paused.
  * @param {object} runtime
- * @param {{ humanWaitCapMs: number }} settings
+ * @param {{ enabled: boolean, humanWaitCapMs: number }} live
  * @param {object} logger
  */
-function patchRun(runtime, settings, logger) {
+function patchRun(runtime, live, logger) {
   const holder = methodHolder(runtime, 'run')
   if (holder === undefined) return undefined
 
@@ -261,12 +266,13 @@ function patchRun(runtime, settings, logger) {
   }
 
   const wrapped = function patchedRun(spec) {
+    if (!live.enabled) return Reflect.apply(original, this, [spec])
     const budget = spec !== null && typeof spec === 'object' ? spec.timeoutMs : undefined
     if (typeof budget !== 'number' || !Number.isFinite(budget) || budget <= 0) {
       return Reflect.apply(original, this, [spec])
     }
     try {
-      return runWithPausedDeadline(original, this, spec, budget, settings, logger)
+      return runWithPausedDeadline(original, this, spec, budget, live, logger)
     } catch (error) {
       logger.warn(`could not wrap run: ${messageOf(error)} — using the shipped deadline`)
       return Reflect.apply(original, this, [spec])
@@ -294,14 +300,14 @@ function patchRun(runtime, settings, logger) {
  * @param {unknown} self
  * @param {object} spec
  * @param {number} budget
- * @param {{ humanWaitCapMs: number }} settings
+ * @param {{ enabled: boolean, humanWaitCapMs: number }} live
  * @param {object} logger
  */
-function runWithPausedDeadline(original, self, spec, budget, settings, logger) {
+function runWithPausedDeadline(original, self, spec, budget, live, logger) {
   const controller = new AbortController()
   const outer = spec.signal
   const signal = outer === undefined ? controller.signal : AbortSignal.any([outer, controller.signal])
-  const cap = settings.humanWaitCapMs === -1 ? Infinity : settings.humanWaitCapMs
+  const capOf = () => (live.humanWaitCapMs === -1 ? Infinity : live.humanWaitCapMs)
 
   let remaining = budget
   let waited = 0
@@ -344,6 +350,7 @@ function runWithPausedDeadline(original, self, spec, budget, settings, logger) {
     if (aborted || finished) return
     settle()
     if (state.waiters > 0) {
+      const cap = capOf()
       if (waited >= cap) {
         expire(`human interaction wait exceeded (${cap}ms)`)
         return
@@ -382,12 +389,38 @@ function runWithPausedDeadline(original, self, spec, budget, settings, logger) {
  * @param {object} config
  */
 export function apply(ctx, config) {
-  const settings = normalizeConfig(config)
   const logger = createLogger(ctx)
+  // The wrappers read this object on every call, so a settings-page save takes
+  // effect without reloading the bundle. `enabled` is not on that page — it is
+  // still re-read here, so turning it off through this patch file applies live.
+  // `humanWaitCapMs` is the current wait cap.
+  const live = normalizeConfig(config)
+
+  // Own the settings page: the browser half renders the form, so the host must
+  // not auto-generate a second one from the Config schema.
+  ctx.inject(['settings'], (child) => {
+    try {
+      child.settings.configure({ auto: false }, ctx.fiber)
+    } catch (error) {
+      logger.warn(`could not take over the settings page: ${messageOf(error)}`)
+    }
+  })
+
+  ctx.effect(() => {
+    const timer = setInterval(() => {
+      const next = normalizeConfig(config)
+      if (next.enabled === live.enabled && next.humanWaitCapMs === live.humanWaitCapMs) return
+      live.enabled = next.enabled
+      live.humanWaitCapMs = next.humanWaitCapMs
+      const cap = live.humanWaitCapMs === -1 ? 'unlimited' : `${live.humanWaitCapMs} ms`
+      logger.info(`settings changed — ${live.enabled ? `enabled, wait cap: ${cap}` : 'disabled'}`)
+    }, POLL_INTERVAL_MS)
+    if (typeof timer.unref === 'function') timer.unref()
+    return () => clearInterval(timer)
+  })
 
-  if (!settings.enabled) {
+  if (!live.enabled) {
     logger.info('disabled by config — leaving the shipped PTC deadline in place')
-    return
   }
 
   ctx.inject(['ptcRuntime', 'userQuestions'], (child) => {
@@ -395,13 +428,13 @@ export function apply(ctx, config) {
       const disposers = []
       try {
         for (const key of ['ask', 'askTimed']) {
-          const dispose = patchWaitMethod(child.userQuestions, key, logger)
+          const dispose = patchWaitMethod(child.userQuestions, key, live, logger)
           if (dispose !== undefined) disposers.push(dispose)
         }
-        const dispose = patchRun(child.ptcRuntime, settings, logger)
+        const dispose = patchRun(child.ptcRuntime, live, logger)
         if (dispose !== undefined) {
           disposers.push(dispose)
-          const cap = settings.humanWaitCapMs === -1 ? 'unlimited' : `${settings.humanWaitCapMs} ms`
+          const cap = live.humanWaitCapMs === -1 ? 'unlimited' : `${live.humanWaitCapMs} ms`
           logger.info(`PTC run deadlines now pause while a human is waiting (wait cap: ${cap})`)
         } else {
           logger.warn('ptcRuntime.run was not patched — human waits will still count against the run deadline')
@@ -418,6 +451,6 @@ export function apply(ctx, config) {
   })
 
   ctx.inject(['approval'], (child) => {
-    child.effect(() => patchWaitMethod(child.approval, 'request', logger) ?? (() => {}))
+    child.effect(() => patchWaitMethod(child.approval, 'request', live, logger) ?? (() => {}))
   })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-human-wait",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Pauses the PTC run_code deadline while DSH is waiting for you to answer a question, review a plan or approve a request, so long human waits are no longer reported as `execution deadline reached (120000ms)`.",
   "license": "MIT",
   "author": {
@@ -23,10 +23,12 @@
     ".": "./index.js",
     "./package.json": "./package.json",
     "./locale/*.json": "./locale/*.json",
-    "./icon": "./icon.svg"
+    "./icon": "./icon.svg",
+    "./client": "./client.js"
   },
   "files": [
     "index.js",
+    "client.js",
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",
@@ -47,6 +49,15 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
     }
   },
   "engines": {
@@ -57,6 +68,6 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node --test test/plugin.test.mjs"
+    "test": "node --test test/plugin.test.mjs test/client.test.mjs"
   }
 }