dsh-mobile-plugin 0.5.0 → 0.5.1

package/lib/client.js

@@ -224,6 +224,15 @@ window.__ModuleLoader__.load({
     /** 自检上报的出口与间隔：只为可观测性存在，不做任何状态变更。 */
     const CLIENT_HALF_ENDPOINT = '/api/relay/client-half';
     const CLIENT_HALF_REPORT_MS = 10000;
+    /**
+     * 宿主半边的自检口（由外壳注册，实现挂了它也还在）。
+     *
+     * 实现装载失败时整张 `/api/relay/*` 都 404，这一项只显示一句「插件宿主侧没有加载」，
+     * 真正的原因（等哪个服务超时、哪一代装不上）就没人看得见。这两条是那个原因唯一的出口；
+     * 第二条点一下就在原地重新装载一次，不必重启整个 DSH。
+     */
+    const HOST_HALF_ENDPOINT = '/api/relay/host-half';
+    const HOST_HALF_RELOAD_ENDPOINT = '/api/relay/host-half/reload';
 
     /**
      * 把 sessionStatus 的快照摊成 [id, status] 列表。
@@ -469,6 +478,10 @@ window.__ModuleLoader__.load({
         panelMissing: '宿主还没给出页面地址，稍后再打开这一页试试。',
         loadFailed: '读取宿主状态失败',
         loadMissing: '插件宿主侧没有加载：把 DSH 完整退出再打开一次；还不行就在插件市场重装一遍插件。',
+        hostHalfReason: '宿主侧报的原因：',
+        hostHalfRetrying: '它还在后台自己重试，过几分钟刷新这一页就能看到结果；也可以点下面的按钮立刻再试一次。',
+        hostHalfReload: '重新装载',
+        hostHalfReloadFailed: '重新装载没成：',
         webAccessOn: '公网网页管理已开放，到期时间',
         webAccessOff: '公网网页管理已关闭',
         webAccessOpen: '开放网页管理 2 小时',
@@ -487,6 +500,10 @@ window.__ModuleLoader__.load({
         panelMissing: 'The host has not reported a page address yet — reopen this item in a moment.',
         loadFailed: 'Failed to read host status',
         loadMissing: 'The plugin host half is not loaded: quit and reopen DSH; if that does not help, reinstall the plugin from the market.',
+        hostHalfReason: 'Reported by the host: ',
+        hostHalfRetrying: 'It is still retrying on its own in the background — reopen this item in a few minutes, or press the button below to retry right now.',
+        hostHalfReload: 'Reload now',
+        hostHalfReloadFailed: 'Reload failed: ',
         webAccessOn: 'Public web management is open until',
         webAccessOff: 'Public web management is closed',
         webAccessOpen: 'Open web management for 2 hours',
@@ -514,6 +531,10 @@ window.__ModuleLoader__.load({
       const [webAccessBusy, setWebAccessBusy] = useState(false);
       /** 最近一次失败的 HTTP 状态码（0 = 网络异常 / 还没失败过）。404 单独说。 */
       const [errorStatus, setErrorStatus] = useState(0);
+      /** 宿主半边自检的结果（外壳给的那份），404 时才有内容。 */
+      const [half, setHalf] = useState(null);
+      const [halfBusy, setHalfBusy] = useState(false);
+      const [halfError, setHalfError] = useState(null);
 
       useEffect(() => {
         let alive = true;
@@ -528,6 +549,8 @@ window.__ModuleLoader__.load({
             if (!alive) return;
             setError(null);
             setErrorStatus(0);
+            setHalf(null);
+            setHalfError(null);
             setPanelUrl(typeof next.panelUrl === 'string' ? next.panelUrl : '');
             setWebAccess(next.webAccess && typeof next.webAccess.enabled === 'boolean' ? next.webAccess : null);
             if (retryTimer !== null) {
@@ -549,6 +572,20 @@ window.__ModuleLoader__.load({
               clearTimer(refreshTimer);
               refreshTimer = null;
             }
+            // 404 = 实现那一半没装载。它为什么没装载，只有外壳答得出来（这两条路由挂在
+            // 外壳上，实现挂了它们还在）；老版本宿主没有这条口，问不到就当没有，别报错。
+            if (problem?.status === 404) {
+              try {
+                const picture = await call(HOST_HALF_ENDPOINT);
+                if (!alive) return;
+                setHalf(picture && typeof picture.half === 'object' ? picture.half : null);
+              } catch {
+                if (!alive) return;
+                setHalf(null);
+              }
+            } else {
+              setHalf(null);
+            }
             // 无权的远程设置页不轮询；宿主还没启动等临时故障每 3s 重试。
             if (problem?.status !== 403 && problem?.status !== 423 && retryTimer === null) {
               retryTimer = setInterval(() => {
@@ -580,6 +617,27 @@ window.__ModuleLoader__.load({
         }
       };
 
+      /**
+       * 让外壳当场把实现再装一次。
+       *
+       * 装载失败那阵子，这是唯一不必重启整个 DSH 的出路；成不成以宿主回来的那份自检为准，
+       * 失败原因原样贴出来（它往往就是「等哪个服务超时」，过一会儿自己就好了）。
+       */
+      const reloadHalf = async () => {
+        if (halfBusy) return;
+        setHalfBusy(true);
+        setHalfError(null);
+        try {
+          const next = await postJson(HOST_HALF_RELOAD_ENDPOINT, {});
+          if (next && typeof next.half === 'object') setHalf(next.half);
+          if (next && next.ok === false) setHalfError(errorText(next, 200));
+        } catch (problem) {
+          setHalfError(String((problem && problem.message) || problem));
+        } finally {
+          setHalfBusy(false);
+        }
+      };
+
       const url = typeof panelUrl === 'string' ? panelUrl : '';
       const webAccessEnabled = Boolean(webAccess && webAccess.enabled);
       const expiresAt = webAccess && Number.isFinite(webAccess.expiresAt)
@@ -588,11 +646,32 @@ window.__ModuleLoader__.load({
       let webAccessStatus = t('webAccessUnavailable');
       if (webAccess) webAccessStatus = webAccessEnabled ? `${t('webAccessOn')} ${expiresAt}` : t('webAccessOff');
 
+      const missing = errorStatus === 404;
+
       return h('div', { className: 'dshm_root' }, [
         h('h2', { className: 'dshm_heading' }, t('heading')),
         error
-          ? h('p', { className: 'dshm_error' }, errorStatus === 404 ? t('loadMissing') : `${t('loadFailed')}: ${error}`)
+          ? h('p', { className: 'dshm_error' }, missing ? t('loadMissing') : `${t('loadFailed')}: ${error}`)
+          : null,
+        // 404 时把宿主那半边自己的说法贴出来：重启 / 重装这两句提示在「装载超时」那种
+        // 现场是帮倒忙的，真正该做的是等它后台补齐、或者点一下重新装载。
+        missing && half && typeof half.lastError === 'string' && half.lastError
+          ? h('p', { className: 'dshm_note' }, `${t('hostHalfReason')}${half.lastError}`)
+          : null,
+        missing && half && half.retrying === true
+          ? h('p', { className: 'dshm_note' }, t('hostHalfRetrying'))
+          : null,
+        missing
+          ? h('div', { className: 'dshm_actions' }, [
+            h('button', {
+              type: 'button',
+              className: 'dshm_btn',
+              disabled: halfBusy,
+              onClick: reloadHalf,
+            }, t('hostHalfReload')),
+          ])
           : null,
+        halfError ? h('p', { className: 'dshm_error' }, `${t('hostHalfReloadFailed')}${halfError}`) : null,
 
         // 用 `<a target="_blank">` 而不是 iframe：DSH 桌面端会把这个链接交给系统浏览器
         // 打开（网页版有自己的地址与刷新节奏，嵌在设置弹窗里反而不好用）。

package/lib/index.js

@@ -28,6 +28,7 @@ import { createRuntime } from './shell/runtime.js'
 import * as updater from './shell/updater.js'
 import { installedPackageDir, installedVersion, profileNodeModules, snapshotRunningGeneration } from './shell/manager.js'
 import { createDeviceOta } from './shell/device-ota.js'
+import { installHostHalf } from './shell/half-route.js'
 
 export const name = 'dsh-mobile-plugin'
 export const inject = ['webServer', 'sessions']
@@ -118,16 +119,21 @@ export function apply(ctx) {
     }
   }, 'dsh-mobile-plugin: generation runtime')
 
+  const installedShellHash = () => updater.shellFingerprint(installedPackageDir())
+
+  // 宿主半边的自检口（实现在 `shell/half-route.js`）：实现装载失败时整张控制面路由
+  // 都不在，只有外壳还活着 —— 那是「它为什么没起来」唯一说得通的落点。
+  ctx.effect(() => installHostHalf(ctx, runtime, { installedVersion, installedShellHash, runningShellHash }), 'dsh-mobile-plugin: host half self check')
+
   ctx.reflect.provide('dshMobilePluginRuntime', {
     status: () => ({
       ...runtime.status(),
       /** 盘上装着的版本（市场装完立刻变，和运行中的版本对照就能看出「要不要换」）。 */
       installedVersion: installedVersion(),
-      /** 盘上那份的外壳指纹与跑着的对不上 = 新版本连外壳一起改了，那部分要等下次启动才生效。 */
       runningShellHash,
-      installedShellHash: updater.shellFingerprint(installedPackageDir()),
+      installedShellHash: installedShellHash(),
       shellChanged: (() => {
-        const installed = updater.shellFingerprint(installedPackageDir())
+        const installed = installedShellHash()
         return installed !== null && runningShellHash !== null && installed !== runningShellHash
       })(),
       profileNodeModules: profileNodeModules(),

package/lib/shell/half-route.js

@@ -0,0 +1,73 @@
+/**
+ * 宿主半边的自检口：`/api/relay/host-half` 与它的 `/reload`。
+ *
+ * 这两条**必须由外壳注册**，不能放进实现：实现装载失败时整张 `/api/relay/*` 都不在，
+ * 而「它为什么没起来」只有外壳答得出来（外壳自己活得好好的是刻意的故障边界）。
+ * 现场的样子是设置页一句「插件宿主侧没有加载」，原因只打在宿主 stderr 里、桌面端不落盘，
+ * 用户看不见、我们也查不出来 —— 这两条就是那个原因唯一的出口。
+ *
+ * 放在 `lib/shell/` 而不是 `lib/index.js` 里，是因为外壳的守卫钉着「只该有装载逻辑」。
+ * 这里只干两件小事：把 state 拍成响应体（`half-view.js`），以及把「重新装载」转给
+ * runtime 那套换代秩序（串行、先停后起、失败回滚）。
+ *
+ * 两条都走 `localOnly`：拒绝中转/局域网转发来的请求、拒绝跨站、钉住 method。它们能读到的
+ * 是这台机器的插件装载状态，不值得让别处看见。
+ */
+
+import { createRequire } from 'node:module'
+import { hostHalfView } from './half-view.js'
+
+const require = createRequire(import.meta.url)
+const { localOnly } = require('../http/routing.js')
+const { sendJson } = require('../shared/http-util.js')
+
+export const HOST_HALF_PATH = '/api/relay/host-half'
+export const HOST_HALF_RELOAD_PATH = '/api/relay/host-half/reload'
+
+/**
+ * 挂上两条路由，返回清理函数（给 `ctx.effect` 当返回值用）。
+ *
+ * @param {object} ctx 外壳那份 context（只用它的 `webServer`）。
+ * @param {{status: () => object, reload: () => Promise<unknown>}} runtime 代际运行时。
+ * @param {{installedVersion?: () => string|null, installedShellHash?: () => string|null,
+ *   runningShellHash?: string|null}} [deps] 盘上那一份的坐标，只为「要不要重启」这一格。
+ */
+export function installHostHalf(ctx, runtime, deps = {}) {
+  const server = ctx?.webServer
+  if (typeof server?.register !== 'function') return () => {}
+  const installedVersion = typeof deps.installedVersion === 'function' ? deps.installedVersion : () => null
+  const installedShellHash = typeof deps.installedShellHash === 'function' ? deps.installedShellHash : () => null
+  const runningShellHash = typeof deps.runningShellHash === 'string' ? deps.runningShellHash : null
+  const view = () => hostHalfView(runtime.status(), {
+    installedVersion: installedVersion(),
+    shellChanged: installedShellHash() !== null && installedShellHash() !== runningShellHash,
+  })
+  const offs = [
+    server.register({
+      kind: 'exact',
+      path: HOST_HALF_PATH,
+      handler: localOnly('GET', async (_req, res) => sendJson(res, 200, view())),
+    }),
+    server.register({
+      kind: 'exact',
+      path: HOST_HALF_RELOAD_PATH,
+      handler: localOnly('POST', async (_req, res) => {
+        try {
+          await runtime.reload()
+          return sendJson(res, 200, view())
+        } catch (error) {
+          // 装载失败时外壳已经按老规矩回滚过了，这里只把原因与回滚后的状态一起交出去：
+          // 面板要能原样显示「还是不行，因为……」。
+          return sendJson(res, 200, {
+            ...view(),
+            ok: false,
+            error: { code: 'reload-failed', message: String((error && error.message) || error) },
+          })
+        }
+      }),
+    }),
+  ].filter(off => typeof off === 'function')
+  return () => {
+    for (const off of offs) off()
+  }
+}

package/lib/shell/half-view.js

@@ -0,0 +1,37 @@
+/**
+ * 宿主半边自检的响应体：把 `runtime.status()` 收成设置页能读的那几格。
+ *
+ * 为什么单独一个纯函数：拼响应体的地方在外壳里，而外壳不好在测试里跑起来（它一 apply
+ * 就真的去装载实现）。这里只做取值与白名单，测试直接喂一份 status 就能钉住形状。
+ *
+ * **`lastError` 是这一条接口存在的理由**：实现装载失败时外壳仍然活着，于是路由 404、
+ * 设置页只显示一句「插件宿主侧没有加载」，而真正的原因（等哪个服务超时、哪一代装不上）
+ * 只打在宿主 stderr 里，桌面端不落盘、用户看不见、我们也就查不出来。这条接口把它原样
+ * 交给设置页。
+ */
+
+/**
+ * @param {object} status `runtime.status()` 的快照。
+ * @param {{installedVersion?: string|null, shellChanged?: boolean}} [extra]
+ *   盘上那一份的坐标（市场装完立刻变，和跑着的对照就看得出要不要重启）。
+ */
+export function hostHalfView(status, extra = {}) {
+  const s = status && typeof status === 'object' ? status : {};
+  const info = extra && typeof extra === 'object' ? extra : {};
+  return {
+    ok: true,
+    half: {
+      version: typeof s.version === 'string' ? s.version : null,
+      source: typeof s.source === 'string' ? s.source : null,
+      previousVersion: typeof s.previousVersion === 'string' ? s.previousVersion : null,
+      activatedAt: typeof s.activatedAt === 'string' ? s.activatedAt : null,
+      lastError: typeof s.lastError === 'string' ? s.lastError : null,
+      /** 启动时那几次没成、现在仍在后台按长间隔重试 —— 面板据此劝人「再等等」而不是重装。 */
+      retrying: s.retrying === true,
+      retryAttempts: Number.isFinite(s.retryAttempts) ? s.retryAttempts : 0,
+      nextRetryAt: typeof s.nextRetryAt === 'string' ? s.nextRetryAt : null,
+      installedVersion: typeof info.installedVersion === 'string' ? info.installedVersion : null,
+      shellChanged: info.shellChanged === true,
+    },
+  };
+}

package/lib/shell/runtime.js

@@ -16,10 +16,26 @@ import { checkGenerationAlive } from './self-check-after-swap.js'
 
 /** 换代前等在飞请求归零的上限。 */
 const DRAIN_TIMEOUT_MS = 2000
-/** 等一代装载完成的上限。装载卡住（依赖永远不来）时不能把整个外壳拖死。 */
-const ACTIVATE_TIMEOUT_MS = 20000
+/**
+ * 等一代装载完成的上限。装载卡住（依赖永远不来）时不能把整个外壳拖死。
+ *
+ * 20s 在慢机器上不够：失败的首要原因就是注入的服务（typertGateway / apiProxy）比本插件
+ * 晚就位，而 Windows 冷启动、装了一堆插件的 DSH 要几十秒才轮到那条服务。真实现场是
+ * 「重启还是不行」—— 设置页一句 404，日志里什么都没有。
+ */
+const ACTIVATE_TIMEOUT_MS = 60000
 /** 首次装载全失败后的重试间隔与次数（重试理由见 `start()`）。 */
 const START_RETRY_LIMIT = 6
+/**
+ * 启动那一轮没成之后，后台继续按这个节奏重试多久。
+ *
+ * 失败代价是**整张控制面路由表都不在**，而根因多半是「服务晚到」这种会自己好的事。
+ * 只重试启动那六次（约五分钟）然后就躺平，等于把一个瞬态问题固定成故障，用户唯一的
+ * 出路是重启 —— 而重启正好又落回同一个时间窗里。这里按长间隔再试一小时，并让设置页
+ * 看得到「还在试」。
+ */
+const RETRY_BACKLOG_MS = 120000
+const RETRY_BACKLOG_LIMIT = 30
 /** 间隔可用环境变量压低，只给测试（与 `DSH_MOBILE_PROFILE_NODE_MODULES` 同款逃生口）。 */
 const START_RETRY_MS = Number(process.env.DSH_MOBILE_START_RETRY_MS) > 0
   ? Number(process.env.DSH_MOBILE_START_RETRY_MS)
@@ -68,6 +84,15 @@ export function createRuntime() {
    * 读到这条已经发生过的事实（`lastApply.rolledBack` 就是从它来的）。
    */
   let lastRollback = null
+  /**
+   * 后台补齐重试的账：启动那一轮失败后接着试，试到成功或额度用完。
+   *
+   * 这三格同时也是说给用户听的：`retrying` 决定面板劝人「再等等」还是「重装」，
+   * `nextRetryAt` 让人知道下一次是几分钟后。
+   */
+  let retryTimer = null
+  let retryAttempts = 0
+  let nextRetryAt = null
 
   /** 对外状态快照。控制面接口直接把它交给客户端。 */
   function status() {
@@ -80,6 +105,9 @@ export function createRuntime() {
       inFlight,
       swapping: swapping !== null,
       lastRollback,
+      retrying: retryTimer !== null,
+      retryAttempts,
+      nextRetryAt,
     }
   }
 
@@ -261,6 +289,7 @@ export function createRuntime() {
             throw error
           }
         }
+        clearBacklogRetry()
         return status()
       } catch (error) {
         // 自检那条已经在上面退回过一次了，别退第二遍（第二遍会把刚装回去的旧代再卸一次）。
@@ -286,37 +315,103 @@ export function createRuntime() {
    * （typertGateway / apiProxy）比本插件晚就位、撞上 20s 装载上限，或者第一次装载撞上
    * IO/时序抖动。一次失败就永久躺平到下次重启，等于把一个瞬态问题固定成故障。
    */
+  /**
+   * 把当前可用的每一代都试一遍：成功就装成当前代并返回 `{ok:true}`，全失败返回
+   * `{ok:false, failures}`。`start()` 与后台补齐重试共用这一份，别各写一遍。
+   *
+   * 候选**现算**而不是启动时抓一份快照：市场换过代、OTA 落过一版之后，这里要能看见新目录。
+   */
+  async function attemptAll() {
+    const failures = []
+    for (const target of resolveGenerations()) {
+      if (detached) throw new Error('插件已经卸载，不再重试装载')
+      try {
+        const { loaded, fiber: startedFiber } = await activate(target)
+        fiber = startedFiber
+        loadedCurrent = loaded
+        current = describe(loaded, target.dir)
+        activatedAt = new Date().toISOString()
+        lastError = failures.length
+          ? `${failures.join('；')}；已回退到 ${target.version}（${target.source}）`
+          : null
+        return { ok: true, version: target.version }
+      } catch (error) {
+        failures.push(`装载 ${target.version}（${target.source}）失败：${error?.message || error}`)
+      }
+    }
+    return { ok: false, failures }
+  }
+
+  /** 停掉后台补齐重试（装成功后调用：再试一次只会撞同一批路由）。 */
+  function clearBacklogRetry() {
+    if (retryTimer !== null) {
+      clearTimeout(retryTimer)
+      retryTimer = null
+    }
+    retryAttempts = 0
+    nextRetryAt = null
+  }
+
+  /**
+   * 启动那一轮没成之后接着试：长间隔、有额度，成功即停。
+   *
+   * 它是 `lastError` 之外的第二次机会，也是「用户什么都不做也能自己好」的那条路。
+   */
+  function scheduleBacklogRetry(log) {
+    if (detached || retryTimer !== null || retryAttempts >= RETRY_BACKLOG_LIMIT) return
+    retryAttempts += 1
+    nextRetryAt = new Date(Date.now() + RETRY_BACKLOG_MS).toISOString()
+    retryTimer = setTimeout(() => {
+      retryTimer = null
+      nextRetryAt = null
+      if (detached) return
+      void attemptAll().then(result => {
+        if (result.ok) {
+          retryAttempts = 0
+          log('info', 'dsh-mobile-plugin: 后台补齐成功，已装载 %s', result.version)
+          return
+        }
+        lastError = `所有可用插件实现均装载失败：${result.failures.join('；')}`
+        log('warn', 'dsh-mobile-plugin: 后台补齐仍未成功：%s', lastError)
+        scheduleBacklogRetry(log)
+      }).catch(error => {
+        lastError = `后台补齐装载出错：${error?.message || error}`
+        scheduleBacklogRetry(log)
+      })
+    }, RETRY_BACKLOG_MS)
+    if (typeof retryTimer.unref === 'function') retryTimer.unref()
+  }
+
+  /**
+   * 第一次激活；最高代装载失败时按优先级尝试保留的回退代；全失败则按固定间隔重试有限次，
+   * 之后交给后台补齐接着试。
+   *
+   * 为什么要重试：一次失败 = **整张控制面路由表都不在**，而设置页
+   * 的「移动端」照样画得出来（客户端半边按包扫描，不看宿主 fiber 活没活），于是现场只表现成
+   * 「读取宿主状态失败: HTTP 404」。失败最常见的原因恰好是**可能自己好**的：注入的服务
+   * （typertGateway / apiProxy）比本插件晚就位、撞上装载上限，或者第一次装载撞上 IO/时序抖动。
+   * 一次失败就永久躺平到下次重启，等于把一个瞬态问题固定成故障。
+   */
   async function start(context, options = {}) {
     ctx = context
     const log = typeof options.log === 'function' ? options.log : () => {}
-    const candidates = resolveGenerations()
-    if (!candidates.length) throw new Error('找不到任何一代实现：包内的 lib/impl.js 缺失')
+    if (!resolveGenerations().length) throw new Error('找不到任何一代实现：包内的 lib/impl.js 缺失')
     let lastFailure = ''
     for (let attempt = 1; attempt <= START_RETRY_LIMIT; attempt += 1) {
-      const failures = []
-      for (const target of candidates) {
-        if (detached) throw new Error('插件已经卸载，不再重试装载')
-        try {
-          const { loaded, fiber: startedFiber } = await activate(target)
-          fiber = startedFiber
-          loadedCurrent = loaded
-          current = describe(loaded, target.dir)
-          activatedAt = new Date().toISOString()
-          lastError = failures.length
-            ? `${failures.join('；')}；已回退到 ${target.version}（${target.source}）`
-            : null
-          return status()
-        } catch (error) {
-          failures.push(`装载 ${target.version}（${target.source}）失败：${error?.message || error}`)
-        }
+      const result = await attemptAll()
+      if (result.ok) {
+        clearBacklogRetry()
+        return status()
       }
-      lastFailure = `所有可用插件实现均装载失败：${failures.join('；')}`
+      lastFailure = `所有可用插件实现均装载失败：${result.failures.join('；')}`
       if (attempt >= START_RETRY_LIMIT) break
       lastError = `${lastFailure}（第 ${attempt} 次，${START_RETRY_MS / 1000}s 后重试）`
       log('warn', 'dsh-mobile-plugin: 装载失败，%d 秒后重试：%s', START_RETRY_MS / 1000, lastFailure)
       await sleep(START_RETRY_MS)
     }
     lastError = lastFailure
+    // 抛出去是为了让外壳那行日志照旧留下；后台补齐另起一条线，两条不冲突。
+    scheduleBacklogRetry(log)
     throw new Error(lastFailure)
   }
 
@@ -331,6 +426,7 @@ export function createRuntime() {
   /** 外壳被卸载时调用：停当前代，之后不再接受换代。 */
   async function detach() {
     detached = true
+    clearBacklogRetry()
     const oldFiber = fiber
     fiber = null
     current = null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (dsh 0.2.x, peers resolved by the host)",
   "license": "MIT",
   "icon": "./icon.png",