dsh-mobile-plugin 0.1.74 → 0.1.76

package/lib/routes/control-plane.js

@@ -640,6 +640,29 @@ function registerControlPlaneRoutes(deps) {
   }) })
 
 
+  // 本机调试 OTA：操作设备端插件实现，不经过公网控制面或中转路由。
+  registerRoute({ kind: 'exact', path: '/api/relay/update/ota/status', handler: localOnly('GET', async (_req, res) => {
+    const runtime = pluginRuntime()
+    if (!runtime || typeof runtime.deviceOta?.status !== 'function') return sendJson(res, 404, { ok: false, error: { code: 'ota_unavailable', message: '当前宿主不支持调试 OTA' } })
+    return sendJson(res, 200, { ok: true, data: runtime.deviceOta?.status() })
+  }) })
+  registerRoute({ kind: 'exact', path: '/api/relay/update/ota/check', handler: localOnly('POST', async (_req, res) => {
+    const runtime = pluginRuntime()
+    if (!runtime || typeof runtime.deviceOta?.check !== 'function') return sendJson(res, 404, { ok: false, error: { code: 'ota_unavailable', message: '当前宿主不支持调试 OTA' } })
+    try { return sendJson(res, 200, { ok: true, data: { update: await runtime.deviceOta?.check(), status: runtime.deviceOta?.status() } }) }
+    catch (error) { return sendJson(res, 500, { ok: false, error: { code: 'ota_check_failed', message: String(error?.message || error) } }) }
+  }) })
+  registerRoute({ kind: 'exact', path: '/api/relay/update/ota/apply', handler: localOnly('POST', async (_req, res) => {
+    const runtime = pluginRuntime()
+    if (!runtime || typeof runtime.deviceOta?.apply !== 'function') return sendJson(res, 404, { ok: false, error: { code: 'ota_unavailable', message: '当前宿主不支持调试 OTA' } })
+    try {
+      const outcome = await runtime.deviceOta?.apply()
+      return sendJson(res, 200, { ok: true, data: { ...outcome, status: runtime.deviceOta?.status() } })
+    } catch (error) {
+      return sendJson(res, 500, { ok: false, error: { code: 'ota_apply_failed', message: String(error?.message || error) } })
+    }
+  }) })
+
   // sidecar 自重启：换掉 worker 子进程 + facade 模块，宿主本身不重启。
   // 走 localOnly——和其余控制面一样，这是本机运维动作。
   registerRoute({ kind: 'exact', path: '/api/relay/restart-sidecar', handler: localOnly('POST', async (_req, res) => {
@@ -670,6 +693,9 @@ const WEB_ACCESS_ROUTES = new Set([
   '/api/relay/update/check',
   '/api/relay/update/apply',
   '/api/relay/update/auto',
+  '/api/relay/update/ota/status',
+  '/api/relay/update/ota/check',
+  '/api/relay/update/ota/apply',
   '/api/relay/restart-sidecar',
 ]);
 

package/lib/routes/mobile-api.js

@@ -31,11 +31,13 @@ const workspaces = require('../mobile/workspaces.js');
 const archiveClean = require('../mobile/archive-clean.js');
 const sessionLog = require('../mobile/session-log.js');
 const hostSettings = require('../mobile/host-settings.js');
+const deepSeekAccount = require('../mobile/deepseek-account.js');
 const skills = require('../mobile/skills.js');
 const mobileCredentials = require('../mobile/credentials.js');
 const subagents = require('../mobile/subagents.js');
 const references = require('../mobile/references.js');
 const plugins = require('../mobile/plugins.js');
+const uploads = require('../mobile/uploads.js');
 // 体检接口要自报身份：版本号只有一个来源，就是包自己的 package.json（与 relay/status.js 同）。
 const pkg = require('../../package.json');
 const desktopView = require('../desktop-view.cjs');
@@ -125,6 +127,7 @@ function registerMobileRoutes(deps) {
   route('/api/mobile/v1/sessions', sessions.handleSessions)
   route('/api/mobile/v1/session', sessions.handleSession)
   route('/api/mobile/v1/session/messages', sessions.handleMessages)
+  route('/api/mobile/v1/session/attachment', sessions.handleSessionAttachment)
   route('/api/mobile/v1/session/send', sessions.handleSend)
   route('/api/mobile/v1/commands', sessions.handleCommands)
   route('/api/mobile/v1/session/read', sessions.handleSessionRead)
@@ -188,6 +191,8 @@ function registerMobileRoutes(deps) {
   // 只能看到 App 自己的偏好项。两个宿主接口本身已脱敏（secrets 只给 path 与 set），
   // 插件再丢掉对手机没用的 schema 树，见 mobile/host-settings.js。
   route('/api/mobile/v1/host-settings', hostSettings.handleHostSettings)
+  // DeepSeek 账号只读投影：账户资料、钱包余额与官方用量/充值链接；不开放登录操作或凭据。
+  route('/api/mobile/v1/deepseek-account', deepSeekAccount.handleDeepSeekAccount)
   // 改设置：与桌面端同一个 settings.mutate（按路径寻址的 op + expectedRevision 乐观并发）。
   route('/api/mobile/v1/host-settings/mutate', hostSettings.handleHostSettingsMutate)
   route('/api/mobile/v1/llm/providers', hostSettings.handleLlmProviders)
@@ -221,6 +226,15 @@ function registerMobileRoutes(deps) {
   // 经 typertGateway 命名空间 pluginInventory 取，见 mobile/plugins.js。
   route('/api/mobile/v1/plugins', plugins.handlePlugins)
 
+  // 分享文件的落地通道（App 把手机分享进来的文件分片传上来，见 mobile/uploads.js）。
+  // 手机端没有「把文件交给宿主」的路：图片能进 session.send 的 base64 内容块，其它格式
+  // 一律进不去。四条端点只做「收字节 → 落盘到 ~/.dsh/mobile-inbox/<日期>/<文件名>」，
+  // 落盘路径由 App 写成 @提及 再随消息发给宿主，所以这里不认识工作区、也不认识会话。
+  route('/api/mobile/v1/upload/begin', uploads.handleUploadBegin)
+  route('/api/mobile/v1/upload/chunk', uploads.handleUploadChunk)
+  route('/api/mobile/v1/upload/finish', uploads.handleUploadFinish)
+  route('/api/mobile/v1/upload/abort', uploads.handleUploadAbort)
+
   // 内置浏览器预览（App 侧「点 localhost 链接在内置浏览器里打开」的宿主端一半）。
   //
   // 这是一条 **WebSocket 升级**路由，不是普通 HTTP 路由：手机原生模块按端口在环回监听、

package/lib/shell/device-ota.js

@@ -0,0 +1,126 @@
+/** 设备端临时插件 OTA：npm 保持正式来源，OTA 仅保存于 DSH home。 */
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { createRequire } from 'node:module'
+import { dshHome } from '../shared/paths.js'
+import { compareVersion } from './manager.js'
+
+const require_ = createRequire(import.meta.url)
+const zlib = require_('node:zlib')
+const ROOT = () => path.join(dshHome(), 'plugin-ota')
+const PACKAGE = 'dsh-mobile-plugin'
+const RELAY = 'https://dsh-hub.wnluo.com/api/desktop-plugins/ota'
+const CHANNEL = 'stable'
+const PLATFORM = process.platform
+function validVersion(value) { return typeof value === 'string' && /^\d+\.\d+\.\d+$/.test(value) }
+function validPackageUrl(value) {
+  try { return new URL(value).protocol === 'https:' } catch { return false }
+}
+function availableOta() {
+  try {
+    return fs.readdirSync(ROOT(), { withFileTypes: true }).filter(item => item.isDirectory()).map(item => {
+      const pkgDir = path.join(ROOT(), item.name, PACKAGE)
+      const pkg = JSON.parse(fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf8'))
+      if (pkg.name !== PACKAGE || !validVersion(pkg.version) || !fs.existsSync(path.join(pkgDir, 'lib', 'impl.js'))) return null
+      return { version: pkg.version, entry: path.join(pkgDir, 'lib', 'impl.js'), dir: pkgDir, pkgDir, source: 'ota' }
+    }).filter(Boolean).sort((a, b) => compareVersion(b.version, a.version))
+  } catch { return [] }
+}
+function clearSuperseded(version) {
+  if (!validVersion(version)) return
+  for (const release of availableOta()) if (compareVersion(version, release.version) >= 0) fs.rmSync(path.dirname(release.pkgDir), { recursive: true, force: true })
+}
+function unpackTarGz(buffer, target) {
+  const tar = zlib.gunzipSync(buffer)
+  let offset = 0
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512)
+    if (header.every(byte => byte === 0)) break
+    const name = header.subarray(0, 100).toString().replace(/\0.*$/, '')
+    const prefix = header.subarray(345, 500).toString().replace(/\0.*$/, '')
+    const rel = path.posix.join(prefix, name)
+    const size = parseInt(header.subarray(124, 136).toString().replace(/\0.*$/, '').trim() || '0', 8)
+    const type = header[156]
+    const start = offset + 512
+    if (!rel.startsWith('package/') || rel.split('/').includes('..')) throw new Error('OTA 包含无效路径')
+    if (type === 0 || type === 48) {
+      const dest = path.join(target, PACKAGE, ...rel.split('/').slice(1))
+      fs.mkdirSync(path.dirname(dest), { recursive: true })
+      fs.writeFileSync(dest, tar.subarray(start, start + size))
+    } else if (type !== 53) throw new Error(`OTA 包包含不支持的 tar 项：${rel}`)
+    offset = start + Math.ceil(size / 512) * 512
+  }
+  const pkgDir = path.join(target, PACKAGE)
+  const pkg = JSON.parse(fs.readFileSync(path.join(pkgDir, 'package.json'), 'utf8'))
+  if (pkg.name !== PACKAGE || !validVersion(pkg.version) || !fs.existsSync(path.join(pkgDir, 'lib', 'impl.js'))) throw new Error('OTA 包结构不完整')
+  return pkg.version
+}
+
+export function createDeviceOta({ fetchImpl = fetch, installed = () => null, platform = PLATFORM, channel = CHANNEL, runtime = null } = {}) {
+  async function reconcileOfficial() {
+    const active = runtime?.status()
+    const officialVersion = installed()
+    if (!runtime || !validVersion(officialVersion)) return { switched: false, status: active ?? null }
+    if (active?.source === 'installed') {
+      clearSuperseded(officialVersion)
+      return { switched: false, status: active }
+    }
+    if (active?.source !== 'ota' || !validVersion(active.version) || compareVersion(officialVersion, active.version) < 0) {
+      return { switched: false, status: active ?? null }
+    }
+    const status = await runtime.reload()
+    if (status?.source === 'installed') clearSuperseded(officialVersion)
+    return { switched: status?.source === 'installed', status }
+  }
+  async function check() {
+    await reconcileOfficial()
+    const url = `${RELAY}/latest?platform=${encodeURIComponent(platform)}&channel=${encodeURIComponent(channel)}`
+    const response = await fetchImpl(url, { headers: { accept: 'application/json' } })
+    if (!response.ok) throw new Error(`OTA relay 返回 HTTP ${response.status}`)
+    const body = await response.json()
+    const release = body?.data
+    if (body?.ok !== true || !validVersion(release?.version) || release.platform !== platform || release.channel !== channel || !validPackageUrl(release.packageUrl)) throw new Error('OTA relay 没有提供匹配平台、stable channel、有效版本或 HTTPS 下载地址')
+    const installedVersion = installed()
+    const officialVersion = installedVersion
+    const ota = availableOta()[0] || null
+    const otaVersion = validVersion(release.version) ? release.version : null
+    const newest = [ota?.version, otaVersion].filter(validVersion).sort((a, b) => compareVersion(b, a))[0] || null
+    const absorbed = Boolean(validVersion(officialVersion) && newest && compareVersion(officialVersion, newest) >= 0 && runtime?.status()?.source !== 'ota')
+    return { available: Boolean(newest && !absorbed && compareVersion(newest, installedVersion || '0.0.0') > 0), version: newest, platform: release.platform || platform, channel: release.channel || channel, installedVersion, otaVersion: ota?.version ?? null, officialVersion, absorbed, packageUrl: release.packageUrl }
+  }
+  async function apply() {
+    const info = await check()
+    if (info.otaVersion && compareVersion(info.otaVersion, info.version) === 0) return { installed: true, version: info.version, source: 'ota', alreadyDownloaded: true }
+    if (validVersion(info.officialVersion) && compareVersion(info.officialVersion, info.version) >= 0) return { installed: false, reason: 'npm-current-or-newer', version: info.officialVersion }
+    const staging = fs.mkdtempSync(path.join(os.tmpdir(), 'dsh-plugin-ota-'))
+    try {
+      const response = await fetchImpl(info.packageUrl)
+      if (!response.ok) throw new Error(`OTA 下载失败：HTTP ${response.status}`)
+      const version = unpackTarGz(Buffer.from(await response.arrayBuffer()), staging)
+      if (version !== info.version) throw new Error(`OTA 版本不匹配：预期 ${info.version}，实际 ${version}`)
+      const releaseDir = path.join(ROOT(), version)
+      fs.mkdirSync(ROOT(), { recursive: true })
+      fs.rmSync(releaseDir, { recursive: true, force: true })
+      fs.renameSync(staging, releaseDir)
+      return { installed: true, version, source: 'ota' }
+    } catch (error) {
+      fs.rmSync(staging, { recursive: true, force: true })
+      throw error
+    }
+  }
+  const status = () => {
+    const installedVersion = installed()
+    const active = runtime?.status() ?? null
+    const ota = availableOta()[0] || null
+    return { available: Boolean(ota && compareVersion(ota.version, installedVersion || '0.0.0') > 0), activeVersion: active?.version ?? installedVersion, otaVersion: ota?.version ?? null, officialVersion: installedVersion, absorbed: Boolean(installedVersion && ota && compareVersion(installedVersion, ota.version) >= 0 && active?.source !== 'ota'), channel }
+  }
+  async function activate() {
+    const outcome = await apply()
+    if (!outcome.installed || !runtime) return { ...outcome, status: runtime?.status() ?? null }
+    const next = await runtime.reload(outcome.version)
+    return { installed: true, version: outcome.version, status: next }
+  }
+  return { status, check, apply: activate, reconcileOfficial }
+}
+export { availableOta, clearSuperseded }

package/lib/shell/manager.js

@@ -5,10 +5,9 @@
  * DSH**（Node 缓存 realpath，换 profile 链接必须重启进程）。手机那边的主机是 systemd
  * 拉起来的，重启一条命令的事；桌面这边用户得自己退出再打开，而他不想每次都做这件事。
  *
- * ## 2026-10 改：代从哪儿来（从「OTA 写进 .live」改成「市场装进 profile」）
+ * ## 2026-10 改：npm 正式代与紧急 OTA 代并存
  *
- * 从前一代是 OTA 下载、解包、写进 `<pkg>/lib/.live/<releaseId>/`；分发交给 DSH 插件市场
- * 之后那套没了，但**换代的判据反而更简单**：市场在 profile 里跑 pnpm，装新版会把
+ * 正式版本由 DSH 插件市场装进 profile；紧急 OTA 将完整包落在 `$DSH_HOME/plugin-ota/`，两者都由代际装载器切换。正式版本安装仍通过 profile 里的 pnpm 完成，安装新版会把
  * `<profile>/node_modules/dsh-mobile-plugin` 这个链接指向**一个全新的 store 目录**：
  *
  *   <profile>/node_modules/dsh-mobile-plugin -> .pnpm/dsh-mobile-plugin@0.1.58/node_modules/dsh-mobile-plugin
@@ -33,6 +32,7 @@ import fs from 'node:fs'
 import { createRequire } from 'node:module'
 import path from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
+import { availableOta } from './device-ota.js'
 
 /** CJS 模块缓存。实现树里 `lib/relay`、`lib/routes`、`lib/mobile` 都是 CJS。 */
 const require_ = createRequire(import.meta.url)
@@ -100,18 +100,20 @@ function readPackageVersion(file) {
 /**
  * 列出所有可用的代。
  *
- * 两个来源：
+ * 三种来源：
  *   · `bundled` —— 外壳自己所在的包（进程启动时那一代）。它可能在运行期间被市场的 pnpm
  *     整个换掉甚至删掉，所以**盘上读不到就列不出来**；那种时候只剩内存里那份
  *     （`imported` 里缓存着），回滚也只能靠它。
- *   · `installed` —— profile 里当前装着的那一份（`node_modules/dsh-mobile-plugin` 的
+ *   · `installed` —— profile 里当前装着的正式版本（`node_modules/dsh-mobile-plugin` 的
  *     realpath）。市场装新版之后这里立刻就是新版本，而且它的 realpath 每次都可能不同，
  *     天然绕开 ESM 缓存（这正是当年要靠 `.live/<releaseId>` 才能拿到的东西）。
+ *   · `ota` —— `$DSH_HOME/plugin-ota/<version>/dsh-mobile-plugin` 的完整紧急包；正式版成功
+ *     接管后才清理已覆盖的 OTA，以便激活失败时重启仍能从磁盘回退。
  *
  * 只做「结构齐不齐」的粗筛：`package.json` 与 `lib/impl.js` 缺一不可。半份拷贝（安装被
  * 打断）如果被当成可用代，下次换代就会用一份残缺的代码上线。
  *
- * @returns {Array<{version: string, entry: string, dir: string|null, pkgDir: string, source: 'bundled'|'installed'}>}
+ * @returns {Array<{version: string, entry: string, dir: string|null, pkgDir: string, source: 'bundled'|'installed'|'ota'}>}
  */
 export function listGenerations() {
   const generations = []
@@ -127,6 +129,8 @@ export function listGenerations() {
       generations.push({ version, entry, dir: installed, pkgDir: installed, source: 'installed' })
     }
   }
+  const otaGenerations = availableOta()
+  generations.push(...otaGenerations)
   return generations
 }
 
@@ -158,30 +162,23 @@ export function installedVersion() {
 /**
  * 取版本号最高的代。
  *
- * `preferVersion` 命中时优先（用于回滚到指定的旧代）。**版本号相同时取装进来的那一代**
- * （`source: 'live'`），理由见下面 `delta === 0` 那一段 —— 这不是审美问题，是「同样报
- * 0.1.16，一个跑新代码一个跑旧代码」的分叉点。
+ * `preferVersion` 命中时优先（用于回滚到指定的旧代）。**版本号相同时优先 installed，其次 ota，最后 bundled**；来源与目录也参与运行时代身份判定，不能只比版本号。
  */
-export function resolveGeneration(preferVersion) {
-  const generations = listGenerations()
-  if (!generations.length) return null
-  if (preferVersion) {
-    const preferred = generations.find(item => item.version === preferVersion)
-    if (preferred) return preferred
-  }
-  return generations.reduce((best, item) => {
-    const delta = compareVersion(item.version, best.version)
-    if (delta > 0) return item
-    // 同版本时必须取 `installed`。基础代（包内 `lib/impl.js`）的路径是**固定**的，而
-    // `importGeneration` 的 `?v=` 只骗得过**入口** —— 入口里 `require('./relay/…')` 那些
-    // CJS 子模块按解析后的真实路径命中缓存，query 传不下去；于是「profile 里的插件包被
-    // pnpm 换过版本」之后再激活固定路径那一代，拿到的仍是进程启动时那份**旧**实现。
-    // 实测过：完整安装之后再自更新，接口回 `installed: true, version: <新版>`，而实际跑
-    // 的还是旧代码 —— 状态说成功、代码没换，是最坏的那种失败。
-    // `installed` 那一代的 realpath 是新目录 = 新 URL，整棵树必然读到新代码。
-    if (delta === 0 && item.source === 'installed' && best.source !== 'installed') return item
-    return best
+export function resolveGenerations(preferVersion) {
+  const generations = listGenerations().sort((a, b) => {
+    const delta = compareVersion(b.version, a.version)
+    if (delta !== 0) return delta
+    const priority = { installed: 2, ota: 1, bundled: 0 }
+    return priority[b.source] - priority[a.source]
   })
+  if (!preferVersion) return generations
+  const preferred = generations.find(item => item.version === preferVersion)
+  return preferred ? [preferred, ...generations.filter(item => item !== preferred)] : generations
+}
+
+/** 取优先级最高的一代；同版正式安装胜过 OTA，再胜过随包版本。 */
+export function resolveGeneration(preferVersion) {
+  return resolveGenerations(preferVersion)[0] ?? null
 }
 
 /**
@@ -241,12 +238,14 @@ function evictCommonJsTree(roots) {
  * import 之前必须先把这棵树的 CJS 缓存清掉（见 `evictCommonJsTree`）。
  */
 const imported = new Map()
+const generationCacheKey = generation => JSON.stringify([generation.source, generation.version, generation.entry])
 
 /** `?v=` 里的序号：同一毫秒内连换两代时，光有时间戳会撞进同一个 URL。 */
 let importSeq = 0
 
 export async function importGeneration(generation) {
-  const cached = imported.get(generation.version)
+  const cacheKey = generationCacheKey(generation)
+  const cached = imported.get(cacheKey)
   if (cached) return cached
   // 先把 CJS 缓存清干净再 import，否则「入口是新的、子模块还是旧的」，等于换了个半成品上去。
   evictCommonJsTree(evictionRoots(generation))
@@ -268,7 +267,7 @@ export async function importGeneration(generation) {
     inject: Array.isArray(mod?.inject) ? mod.inject : null,
     hostPath: generation.dir,
   }
-  imported.set(generation.version, loaded)
+  imported.set(cacheKey, loaded)
   return loaded
 }
 
@@ -279,6 +278,6 @@ export async function importGeneration(generation) {
  * 重读目录，所以这里只需要把该版本可能存在的旧缓存丢掉，强制下次 import 读新文件。
  */
 export function invalidateGeneration(version) {
-  if (version) imported.delete(version)
-  else imported.clear()
+  if (!version) return imported.clear()
+  for (const [key, loaded] of imported) if (loaded.version === version) imported.delete(key)
 }

package/lib/shell/runtime.js

@@ -19,7 +19,7 @@
  * 卡住的请求不该拖住一次修复性更新）。
  */
 
-import { importGeneration, resolveGeneration } from './manager.js'
+import { importGeneration, resolveGeneration, resolveGenerations } from './manager.js'
 
 /** 换代前等在飞请求归零的上限。 */
 const DRAIN_TIMEOUT_MS = 2000
@@ -125,7 +125,8 @@ export function createRuntime() {
     swapping = (async () => {
       const target = resolveGeneration(preferVersion)
       if (!target) throw new Error('找不到任何一代实现：包内的 lib/impl.js 缺失')
-      if (current && target.version === current.version) return status()
+      // 同版本也可能从 OTA 切到 npm：来源与 realpath 不同就必须重新装载。
+      if (current && target.version === current.version && target.source === current.source && target.dir === current.hostPath) return status()
 
       await drain()
       const oldFiber = fiber
@@ -184,17 +185,28 @@ export function createRuntime() {
     return swapping
   }
 
-  /** 第一次激活。 */
+  /** 第一次激活；最高代装载失败时按优先级尝试保留的回退代。 */
   async function start(context) {
     ctx = context
-    const target = resolveGeneration()
-    if (!target) throw new Error('找不到任何一代实现：包内的 lib/impl.js 缺失')
-    const { loaded, fiber: startedFiber } = await activate(target)
-    fiber = startedFiber
-    loadedCurrent = loaded
-    current = describe(loaded, target.dir)
-    activatedAt = new Date().toISOString()
-    return status()
+    const candidates = resolveGenerations()
+    if (!candidates.length) throw new Error('找不到任何一代实现：包内的 lib/impl.js 缺失')
+    const failures = []
+    for (const target of candidates) {
+      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}`)
+      }
+    }
+    throw new Error(`所有可用插件实现均装载失败：${failures.join('；')}`)
   }
 
   /** 等在飞请求结束（最多 `DRAIN_TIMEOUT_MS`）。 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mobile-plugin",
-  "version": "0.1.74",
+  "version": "0.1.76",
   "description": "Mobile API (/api/mobile/v1) and relay client for the DSH mobile app — desktop profile build (0.2.0-rc.2 compatible, peers resolved by the host)",
   "license": "MIT",
   "type": "module",