dsh-x-core 0.1.21 → 0.1.23

package/perf/plugin-profile.mjs

@@ -0,0 +1,204 @@
+/**
+ * 插件启动体检：正常启动路径上顺手采样，按包统计启动期 CPU 与内存分配。
+ *
+ * 为什么不用「每个 entry 的墙钟耗时」：Cordis 是并发初始化插件的，所有 entry 同时开始，
+ * 逐个计时每个人都是 3–5 秒，区分不出谁真的费时。这里改用 V8 采样剖析：
+ * - CPU：Profiler 采样主线程，按调用栈 URL 归到包，得到每个包的独占 CPU 时间；
+ * - 内存：HeapProfiler 采样分配，按调用栈 URL 归到包，得到启动期分配量（不是常驻占用）。
+ *
+ * 只观测，不改变启动顺序：采样器本身开销约 1–2%，启动稳定后停掉并写一个 JSON。
+ * loader 钩子锚点匹配不到时（dsh 升级改了实现）没有 entry 时间线，但采样仍然有效。
+ */
+import { Session } from 'node:inspector/promises'
+import { mkdirSync, renameSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const KEY = Symbol.for('dsh-x/plugin-profile')
+const DIR = process.env.DSH_X_PLUGIN_PROFILE_DIR || ''
+const NAME = process.env.DSH_X_PLUGIN_PROFILE || ''
+const VERSION = process.env.DSH_VERSION || ''
+const PROFILE = process.env.DSH_PROFILE || ''
+/** 启动器给的「版本@profile」才是这次实例的真实身份（DSH_PROFILE 只是管理器当前选中的那份）。 */
+const [REPORT_VERSION, REPORT_PROFILE] = NAME.includes('@')
+  ? [NAME.slice(0, NAME.indexOf('@')), NAME.slice(NAME.indexOf('@') + 1)]
+  : [VERSION, PROFILE]
+/** 落盘文件名只留安全字符，报告内容仍用原始版本/profile。 */
+const REPORT_NAME = (NAME || `${VERSION}@${PROFILE}`).replace(/[^0-9A-Za-z@._-]/g, '_')
+/** CPU 采样间隔（微秒）：1ms，开销小到启动时间上看不出来。 */
+const CPU_INTERVAL_US = 1000
+/** 最后一个 entry 稳定后再等这么久才收尾：给异步 apply 留出完成时间。 */
+const IDLE_MS = 1500
+/** 兜底：有 entry 一直不结算时也不能让采样器永远开着。 */
+const MAX_MS = 120_000
+
+const pending = new Map()
+const entries = []
+let session = null
+let startedAt = 0
+let timer = null
+let cap = null
+let stopped = false
+
+function packageOf(url, names) {
+  const normalized = String(url || '').replace(/\\/g, '/')
+  if (!normalized) return '(原生/GC)'
+  const matched = /node_modules\/(@[^/]+\/[^/]+|[^/]+)\//.exec(normalized)
+  if (matched) return matched[1]
+  // 链接安装的插件不在 node_modules 下：用 loader 报上来的包名对路径
+  for (const name of names) {
+    if (normalized.includes(`/${name}/`)) return name
+  }
+  if (normalized.startsWith('node:')) return '(Node 内部)'
+  if (normalized.includes('/perf/')) return '(启动器钩子)'
+  return '(其他)'
+}
+
+function summarize(cpuProfile, heapProfile) {
+  const names = new Set(entries.map((row) => row.name).filter((name) => name && !name.startsWith('cordis:')))
+  const nodes = new Map((cpuProfile.nodes || []).map((node) => [node.id, node]))
+  const cpuUs = new Map()
+  const nativeUs = new Map()
+  let totalUs = 0
+  let idleUs = 0
+  const samples = cpuProfile.samples || []
+  const deltas = cpuProfile.timeDeltas || []
+  for (let index = 0; index < samples.length; index += 1) {
+    const delta = deltas[index] || 0
+    totalUs += delta
+    const node = nodes.get(samples[index])
+    const fn = node?.callFrame?.functionName || ''
+    if (fn === '(idle)' || fn === '(root)') { idleUs += delta; continue }
+    const url = node?.callFrame?.url || ''
+    if (!url) {
+      // 没有 URL 的帧：GC、V8 编译/内置函数。单列出来，否则会盖住插件的账。
+      const key = fn || '(匿名原生)'
+      nativeUs.set(key, (nativeUs.get(key) || 0) + delta)
+      continue
+    }
+    const pkg = packageOf(url, names)
+    cpuUs.set(pkg, (cpuUs.get(pkg) || 0) + delta)
+  }
+
+  const allocBytes = new Map()
+  let totalAlloc = 0
+  const walk = (node) => {
+    if (!node) return
+    const size = node.selfSize || 0
+    if (size > 0) {
+      const pkg = packageOf(node.callFrame?.url, names)
+      allocBytes.set(pkg, (allocBytes.get(pkg) || 0) + size)
+      totalAlloc += size
+    }
+    for (const child of node.children || []) walk(child)
+  }
+  walk(heapProfile?.head)
+
+  const packages = [...new Set([...cpuUs.keys(), ...allocBytes.keys()])].map((name) => ({
+    name,
+    cpuMs: Math.round((cpuUs.get(name) || 0) / 1000),
+    allocKB: Math.round((allocBytes.get(name) || 0) / 1024),
+    plugin: names.has(name),
+  })).sort((a, b) => b.cpuMs - a.cpuMs)
+
+  return {
+    version: REPORT_VERSION,
+    profile: REPORT_PROFILE,
+    at: Date.now(),
+    windowMs: Math.round(performance.now() - startedAt),
+    cpuMs: Math.round(totalUs / 1000),
+    idleMs: Math.round(idleUs / 1000),
+    allocMB: +(totalAlloc / 1048576).toFixed(1),
+    packages,
+    native: [...nativeUs.entries()]
+      .map(([name, us]) => ({ name, cpuMs: Math.round(us / 1000) }))
+      .sort((a, b) => b.cpuMs - a.cpuMs)
+      .slice(0, 12),
+    entries,
+  }
+}
+
+function writeReport(report) {
+  try {
+    mkdirSync(DIR, { recursive: true })
+    const file = join(DIR, `${REPORT_NAME}.json`)
+    const temp = `${file}.tmp`
+    writeFileSync(temp, JSON.stringify(report))
+    renameSync(temp, file)
+  } catch { /* 体检写不进去不能影响启动 */ }
+}
+
+async function stop() {
+  if (stopped) return
+  stopped = true
+  if (timer !== null) { clearTimeout(timer); timer = null }
+  if (cap !== null) { clearTimeout(cap); cap = null }
+  if (!session) return
+  try {
+    const cpu = await session.post('Profiler.stop')
+    // 堆分配采样已撤：账本只看 CPU；内存用启动结算时读一次 RSS。
+    writeReport(summarize(cpu.profile, null))
+  } catch { /* 采样失败不能影响运行 */ }
+  try { session.disconnect() } catch { /* ignore */ }
+}
+
+function schedule() {
+  if (timer !== null) clearTimeout(timer)
+  timer = setTimeout(() => { void stop() }, IDLE_MS)
+  timer.unref?.()
+}
+
+function settle(entry, failed) {
+  const row = pending.get(entry)
+  if (!row || row.done) return
+  row.done = true
+  pending.delete(entry)
+  entries.push({
+    name: row.name,
+    startMs: Math.round(row.started - startedAt),
+    endMs: Math.round(performance.now() - startedAt),
+    heapKB: Math.round(process.memoryUsage().heapUsed / 1024),
+    ...(failed ? { failed: true } : {}),
+  })
+  schedule()
+}
+
+async function start() {
+  if (!DIR) return
+  try {
+    session = new Session()
+    session.connect()
+    await session.post('Profiler.enable')
+    await session.post('Profiler.setSamplingInterval', { interval: CPU_INTERVAL_US })
+    await session.post('Profiler.start')
+    startedAt = performance.now()
+    cap = setTimeout(() => { void stop() }, MAX_MS)
+    cap.unref?.()
+  } catch {
+    session = null
+  }
+}
+
+export function installPluginProfile() {
+  if (!DIR) return
+  globalThis[KEY] = {
+    enter(entry) {
+      if (!entry || pending.has(entry)) return
+      pending.set(entry, { name: nameOf(entry), started: performance.now() })
+    },
+    imported(entry) {
+      const row = pending.get(entry)
+      if (!row) return
+      const fiber = entry?.fiber
+      if (fiber && typeof fiber.await === 'function') {
+        // fiber 进入 active（或失败）才算这个插件启动完；apply 里的异步初始化都在里面。
+        fiber.await().then(() => settle(entry, false), () => settle(entry, true))
+      } else settle(entry, false)
+    },
+  }
+  void start()
+}
+
+function nameOf(entry) {
+  const name = entry?.options?.name
+  return typeof name === 'string' && name ? name : String(entry?.options?.id || 'unknown')
+}

package/perf/register.mjs

@@ -1,7 +1,11 @@
 import { registerHooks } from 'node:module'
 import { load } from './patch-hooks.mjs'
+import { installPluginProfile } from './plugin-profile.mjs'
 import { createStartupResolver, installationRoots, STARTUP_RESOLVER } from './startup-resolver.mjs'
 
+// 启动 CPU 账本：只在启动器给了输出目录时启用，启动窗口内采一次，结算后停。
+installPluginProfile()
+
 const resolver = createStartupResolver({
   roots: installationRoots(process.env.DSH_BIN),
   enabled: process.env.DSH_PERF_RESOLVE_CACHE !== '0',

package/platform.js

@@ -14,6 +14,7 @@ const ROOT = dirname(fileURLToPath(import.meta.url))
 
 export const IS_WINDOWS = process.platform === 'win32'
 export const IS_MAC = process.platform === 'darwin'
+export const IS_LINUX = process.platform === 'linux'
 
 /** 管理服务是不是跑在 Electron 主进程里（Windows/macOS 外壳都是，见 shell/main.mjs）。 */
 export const IN_ELECTRON = Boolean(process.versions.electron)
@@ -65,5 +66,5 @@ export const APP_DIR_NAME = 'DSH'
 /** macOS 包的名字和 bundle id：Info.plist、LaunchAgent、自更新都认它们。 */
 export const MAC_APP_NAME = 'DSH-X.app'
 export const MAC_BUNDLE_ID = 'io.github.yyh-001.dsh-x'
-/** 外壳可执行文件名（Windows：Cargo.toml 的 [[bin]] name；macOS：Electron 包的 executableName）。 */
+/** 外壳可执行文件名（两个平台都来自 electron-builder 的 executableName，Windows 上就是 NSIS 的主程序名）。 */
 export const LAUNCHER_NAME = 'DSH'