dsh-panel-control 0.3.12 → 0.3.14

package/README.md

@@ -157,6 +157,8 @@ npm run enable -- --disable    # 三步一起撤掉
 npm run doctor                 # 只检查：每个 bundle 是否都能解析
 ```
 
+（这三个脚本随包发布，装成 npm 包后也能直接跑；`.scratch/harness.html` 只在仓库里。）
+
 `doctor` 也会揪出别的断链插件（指向已删除目录的 `link:` 依赖、名字与 `package.json` 不符的包），它只读真实 profile，不改任何东西。
 
 **二、Node 定时器里的回调没有错误边界。** `setTimeout` / `Promise` 回调不在 Cordis 的 `apply` 调用栈里，那里抛出的异常没人接，就是进程级 fatal。第一个版本正是在 20 秒看门狗里调了一个已被删掉的函数，启动 20 秒后必崩，日志里只留一行「客户端半没上报」。

package/client.js

@@ -2089,4 +2089,3 @@ window.__ModuleLoader__.load({
   },
 });
 
-

package/index.js

@@ -44,7 +44,20 @@ const LOG_KEEP_BYTES = 256 * 1024;
 const CLIENT_FILE = fileURLToPath(new URL('./client.js', import.meta.url));
 
 /** Set `DPC_NUDGE=off` to keep the Host strictly read-only about its own files. */
-const NUDGE_ENABLED = String(process.env.DPC_NUDGE || '').toLowerCase() !== 'off';
+/**
+ * The nudge is opt-in, and that default is deliberate.
+ *
+ * Rewriting `client.js` makes the loader hot-swap this module into the live
+ * page. That re-evaluation runs the whole slot reconcile again, and a plugin
+ * whose registration is not idempotent then throws on its second
+ * `register({ id: 'workspace-control' })` and loses its sidebar entry: healing
+ * this plugin broke a neighbour's. A page reload fixes the frozen list without
+ * touching anyone else, so the safe path is the banner, and the nudge stays
+ * behind DPC_NUDGE=on for people who need it and accept the risk.
+ */
+const NUDGE_ENABLED = ['on', '1', 'true', 'yes'].includes(
+  String(process.env.DPC_NUDGE || '').trim().toLowerCase(),
+);
 
 /** Set once the nudge below actually rewrote the Client file in this process. */
 let recoveredAt = 0;
@@ -503,6 +516,32 @@ function inventorySnapshot(scope) {
   };
 }
 
+/**
+ * Write one line per apply that answers the only question a cold start leaves
+ * open: did this package even reach the Host's plugin graph?
+ *
+ * The page can only load what the graph advertises, so "missing from the list"
+ * and "listed but never fetched" have completely different fixes. One line,
+ * once per apply, settles it from `host.log` alone.
+ */
+function logInventoryOnApply(scope) {
+  try {
+    const snapshot = inventorySnapshot(scope);
+    if (!snapshot.ok) {
+      logHost(`graph: unreadable (${String(snapshot.error && snapshot.error.message)})`);
+      return;
+    }
+    const value = snapshot.value;
+    const listed = value.ids.includes(PACKAGE);
+    logHost(
+      `graph: ${listed ? 'lists' : 'does not list'} ${PACKAGE} · rev ${value.rev} · ` +
+        `${value.ids.length} client entr${value.ids.length === 1 ? 'y' : 'ies'}`,
+    );
+  } catch (error) {
+    logHost(`graph: probe failed (${describeError(error)})`);
+  }
+}
+
 /**
  * Say it out loud when the page never came back.
  *
@@ -545,17 +584,33 @@ async function watchFirstClientBoot(startedAt) {
     // while developing) must not be reported as "the window never got the code".
     if (newest >= startedAt - 120_000) return;
     logHost(
-      'client half did not report within 12s: the window is running a plugin list from before this code.',
+      'client half did not report within 30s: the window is running a plugin list from before this code ' +
+        '(a rebuilt interface can take this long to finish loading; press the refresh button if the entry is missing)',
     );
     // The page will not ask for a script that is not in its frozen list, but it
     // does watch this package's files: one byte-level change to the Client entry
     // makes the loader hand the module to the live page. Flip the trailing
     // newline, so the file stays byte-stable instead of growing on every launch.
     if (!NUDGE_ENABLED) {
-      logHost('recovery nudge disabled by DPC_NUDGE=off; the entry stays hidden until the page reloads');
+      logHost('recovery nudge stayed off (opt in with DPC_NUDGE=on); a page reload is the safe fix');
       return;
     }
     try {
+      // The page may have reported while this timer was waiting: never rewrite a
+      // file the running page just loaded, because the resulting hot swap is
+      // what re-runs everybody's registration.
+      const late = await fs.readFile(CLIENT_LOG, 'utf8').catch(() => '');
+      const quiet = late
+        .split(String.fromCharCode(10))
+        .some((line) => {
+          if (!line.includes('"kind":"boot"')) return false;
+          const stamp = Date.parse(line.slice(0, line.indexOf(' ')));
+          return Number.isFinite(stamp) && stamp >= since;
+        });
+      if (quiet) {
+        logHost('recovery nudge skipped: the page reported while the watchdog was waiting');
+        return;
+      }
       const source = await fs.readFile(CLIENT_FILE, 'utf8');
       const next = source.endsWith(NL + NL) ? source.slice(0, -1) : source + NL;
       await fs.writeFile(CLIENT_FILE, next, 'utf8');
@@ -607,6 +662,7 @@ export function apply(ctx) {
     }
     if (dispose) {
       logHost(`route mounted at ${ROUTE_PATH} (attempt ${attempts})`);
+      logInventoryOnApply(scope);
       const startedAt = Date.now();
       // A timer callback that throws is fatal for the Host: contain it here and
       // again inside the async body.
@@ -614,7 +670,7 @@ export function apply(ctx) {
         void watchFirstClientBoot(startedAt).catch((error) =>
           logHost(`client boot watchdog failed: ${describeError(error)}`),
         );
-      }, 12_000);
+      }, 30_000);
       if (typeof watchdog.unref === 'function') watchdog.unref();
       return;
     }

package/package.json

@@ -1,57 +1,62 @@
-{
-  "name": "dsh-panel-control",
-  "version": "0.3.12",
-  "type": "module",
-  "description": "Manage the global panel navigation at the top of the DSH sidebar: reorder, hide and group every entry, with the layout persisted per installation.",
-  "keywords": [
-    "dsh",
-    "dsh-plugin",
-    "deepseek-harness",
-    "sidebar",
-    "panel"
-  ],
-  "exports": {
-    ".": "./index.js",
-    "./client": "./client.js",
-    "./icon": "./icon.svg"
-  },
-  "files": [
-    "LICENSE",
-    "README.md",
-    "assets",
-    "client.js",
-    "cordis.patch.yml",
-    "docs",
-    "icon.svg",
-    "index.js",
-    "screenshots.json"
-  ],
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "platform": "web",
-      "immediately": true,
-      "inject": []
-    }
-  },
-  "license": "MIT",
-  "author": {
-    "name": "QIUZAIYOU"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/QIUZAIYOU/dsh-panel-control.git"
-  },
-  "homepage": "https://github.com/QIUZAIYOU/dsh-panel-control#readme",
-  "bugs": {
-    "url": "https://github.com/QIUZAIYOU/dsh-panel-control/issues"
-  },
-  "scripts": {
-    "check": "node --check index.js && node --check client.js && node scripts/host-smoke.mjs",
-    "smoke": "node scripts/host-smoke.mjs",
-    "doctor": "node scripts/profile-doctor.mjs",
-    "enable": "node scripts/enable-local.mjs"
-  }
-}
+{
+  "name": "dsh-panel-control",
+  "version": "0.3.14",
+  "type": "module",
+  "description": "Manage the global panel navigation at the top of the DSH sidebar: reorder, hide and group every entry, with the layout persisted per installation.",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "sidebar",
+    "panel"
+  ],
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "assets",
+    "client.js",
+    "cordis.patch.yml",
+    "docs",
+    "icon.svg",
+    "index.js",
+    "screenshots.json",
+    "scripts"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": []
+    }
+  },
+  "license": "MIT",
+  "author": {
+    "name": "QIUZAIYOU"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/QIUZAIYOU/dsh-panel-control.git"
+  },
+  "homepage": "https://github.com/QIUZAIYOU/dsh-panel-control#readme",
+  "bugs": {
+    "url": "https://github.com/QIUZAIYOU/dsh-panel-control/issues"
+  },
+  "scripts": {
+    "check": "node --check index.js && node --check client.js && node scripts/host-smoke.mjs",
+    "smoke": "node scripts/host-smoke.mjs",
+    "doctor": "node scripts/profile-doctor.mjs",
+    "enable": "node scripts/enable-local.mjs"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/scripts/enable-local.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * Installs this plugin into a DSH profile in the one order that cannot leave a
+ * half-configured profile behind: dependency → node_modules link → bundle list.
+ *
+ * A name in `dsh.profile.bundles` that nothing can resolve is fatal at startup,
+ * and the Host hits it outside any per-plugin error boundary, so the app dies
+ * instead of skipping the plugin. Adding the three parts in any other order
+ * (or only some of them) is what produces that state.
+ *
+ * Usage:
+ *   node scripts/enable-local.mjs                 # the desktop profile
+ *   node scripts/enable-local.mjs --profile <dir>
+ *   node scripts/enable-local.mjs --disable       # remove all three parts again
+ *
+ * Every step is verified before the next one runs, and a failure rolls the
+ * profile back to what it was.
+ */
+import { existsSync, lstatSync, readFileSync, readdirSync, symlinkSync, unlinkSync, writeFileSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const pluginDir = resolve(here, '..');
+const pluginName = JSON.parse(readFileSync(join(pluginDir, 'package.json'), 'utf8')).name;
+
+const args = process.argv.slice(2);
+const disable = args.includes('--disable');
+const profileFlag = args.indexOf('--profile');
+const profileDir =
+  profileFlag >= 0 ? resolve(args[profileFlag + 1]) : join(homedir(), '.dsh', 'profiles', 'desktop');
+const manifestPath = join(profileDir, 'package.json');
+
+if (!existsSync(manifestPath)) {
+  console.error(`no profile at ${profileDir}`);
+  process.exit(1);
+}
+
+const original = readFileSync(manifestPath, 'utf8');
+const manifest = JSON.parse(original);
+manifest.dsh ||= {};
+manifest.dsh.profile ||= {};
+const bundles = Array.isArray(manifest.dsh.profile.bundles) ? manifest.dsh.profile.bundles : [];
+const linkPath = join(profileDir, 'node_modules', pluginName);
+const spec = `link:${pluginDir.replace(/\\/g, '/')}`;
+
+function linkExists() {
+  try {
+    return lstatSync(linkPath).isSymbolicLink() || lstatSync(linkPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function writeManifest() {
+  writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+}
+
+function rollback(reason) {
+  writeFileSync(manifestPath, original, 'utf8');
+  console.error(`rolled back: ${reason}`);
+  process.exit(1);
+}
+
+function doctor() {
+  try {
+    const out = execFileSync(process.execPath, [join(here, 'profile-doctor.mjs'), '--profile', profileDir], {
+      encoding: 'utf8',
+    });
+    process.stdout.write(out);
+    return true;
+  } catch (error) {
+    process.stdout.write(error.stdout || '');
+    return false;
+  }
+}
+
+if (disable) {
+  manifest.dependencies && delete manifest.dependencies[pluginName];
+  manifest.dsh.profile.bundles = bundles.filter((name) => name !== pluginName);
+  writeManifest();
+  if (linkExists()) unlinkSync(linkPath);
+  console.log(`disabled ${pluginName} in ${profileDir}`);
+  doctor();
+  process.exit(0);
+}
+
+// 1. dependency
+manifest.dependencies ||= {};
+manifest.dependencies[pluginName] = spec;
+writeManifest();
+
+// 2. link — same shape as every other local plugin in the profile
+if (!existsSync(linkPath)) {
+  const target = process.platform === 'win32' ? 'junction' : 'dir';
+  try {
+    symlinkSync(pluginDir, linkPath, target);
+  } catch (error) {
+    rollback(`could not link ${linkPath}: ${(error && error.message) || error}`);
+  }
+}
+if (!existsSync(join(linkPath, 'package.json'))) {
+  rollback(`${linkPath} does not resolve to a package`);
+}
+
+// 3. bundle list, last, and only once 1 and 2 are true
+if (!bundles.includes(pluginName)) {
+  const anchor = bundles.indexOf('dsh-workspace-control');
+  if (anchor >= 0) bundles.splice(anchor, 0, pluginName);
+  else bundles.push(pluginName);
+}
+manifest.dsh.profile.bundles = bundles;
+writeManifest();
+
+console.log(`enabled ${pluginName} in ${profileDir} (bundle #${bundles.indexOf(pluginName) + 1} of ${bundles.length})`);
+if (!doctor()) {
+  rollback('the profile still has an unresolvable bundle');
+}

package/scripts/host-smoke.mjs

@@ -0,0 +1,226 @@
+/**
+ * Host-half smoke test.
+ *
+ * The Host half runs inside the app process, so a mistake here is a crash, not
+ * a red console line: one uncaught ReferenceError in a timer took the whole app
+ * down once. This harness imports the real module, calls `apply` with a fake
+ * Cordis scope, runs every deferred callback it scheduled, and drives the
+ * registered route. It fails on any thrown error.
+ *
+ *   node .scratch/host-smoke.mjs
+ */
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import path from 'node:path';
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+// `npm run smoke -- <file>` points the harness at another copy, which is how
+// a regression (or the broken revision that shipped once) gets reproduced.
+const override = process.argv[2];
+const MODULE = pathToFileURL(override ? path.resolve(override) : path.join(here, '..', 'index.js')).href;
+
+// The recovery nudge rewrites the real client.js when a page never reports; the
+// harness must stay read-only about the checkout.
+process.env.DPC_NUDGE = 'off';
+
+const timers = [];
+const realSetTimeout = globalThis.setTimeout;
+globalThis.setTimeout = (fn, ms, ...rest) => {
+  const handle = { fn, ms, cleared: false };
+  timers.push(handle);
+  return handle;
+};
+globalThis.clearTimeout = (handle) => {
+  if (handle && typeof handle === 'object') handle.cleared = true;
+};
+
+const failures = [];
+function check(name, ok, detail) {
+  if (ok) {
+    console.log(`  ok   ${name}`);
+  } else {
+    failures.push(`${name}${detail ? `: ${detail}` : ''}`);
+    console.log(`  FAIL ${name}${detail ? `: ${detail}` : ''}`);
+  }
+}
+
+const registrations = [];
+const scope = {
+  get(key) {
+    if (key === 'connection') {
+      return {
+        fetch: {
+          register(options) {
+            registrations.push(options);
+            return () => {};
+          },
+          get() {},
+        },
+      };
+    }
+    if (key === 'clientModules') {
+      return { graph: () => ({ rev: 'rev-test', release: 'rel', entries: [{ id: 'a' }, { id: 'b' }], batches: [] }) };
+    }
+    return undefined;
+  },
+};
+
+const effects = [];
+const ctx = {
+  inject(deps, cb) {
+    cb(scope);
+  },
+  effect(factory) {
+    const dispose = factory();
+    effects.push(dispose);
+    return () => {};
+  },
+  get(key) {
+    return scope.get(key);
+  },
+  on() {},
+  logger: { error: () => {}, warn: () => {}, info: () => {} },
+};
+
+console.log('host-smoke');
+let mod;
+try {
+  mod = await import(MODULE);
+  check('module imported', typeof mod.apply === 'function');
+} catch (error) {
+  check('module imported', false, error.message);
+  process.exit(1);
+}
+
+try {
+  mod.apply(ctx);
+  check('apply() did not throw', true);
+} catch (error) {
+  check('apply() did not throw', false, error.message);
+}
+
+check('route registered', registrations.length === 1, `got ${registrations.length}`);
+
+// A hot replace runs `apply` again in the same process, before the old half is
+// disposed: the second run must be as harmless as the first.
+try {
+  mod.apply(ctx);
+  check('apply() again did not throw', true);
+} catch (error) {
+  check('apply() again did not throw', false, error.message);
+}
+const route = registrations[0];
+check(
+  'route path',
+  route && route.path === '/api/dsh-panel-control/classify',
+  route && route.path,
+);
+
+// Every deferred callback must survive being run: a timer body is outside every
+// error boundary the Host has.
+for (const timer of timers) {
+  if (timer.cleared) continue;
+  try {
+    timer.fn();
+    check(`timer(${timer.ms}ms) survived`, true);
+  } catch (error) {
+    check(`timer(${timer.ms}ms) survived`, false, error.message);
+  }
+}
+// The nudge is the one timer body that writes to the checkout: prove that the
+// harness, and any Host started with DPC_NUDGE=off, leaves client.js alone.
+{
+  const fs = await import('node:fs/promises');
+  const clientPath = path.join(here, '..', 'client.js');
+  const before = await fs.readFile(clientPath, 'utf8');
+  await new Promise((resolve) => realSetTimeout(resolve, 120));
+  const after = await fs.readFile(clientPath, 'utf8');
+  check('client.js untouched with DPC_NUDGE=off', before === after, `${before.length} -> ${after.length}`);
+}
+
+// Give the async timer bodies a beat to settle.
+await new Promise((resolve) => realSetTimeout(resolve, 150));
+
+if (route) {
+  const request = (payload, headers) => ({
+    method: 'POST',
+    headers: new Headers({ host: '127.0.0.1:1234', origin: 'http://127.0.0.1:1234', 'content-type': 'application/json', ...headers }),
+    text: async () => JSON.stringify(payload),
+    json: async () => payload,
+  });
+  const envelope = (method) => ({
+    type: 'client-request',
+    rpcId: 'r1',
+    method: 'dsh-panel-control/classify',
+    payload: { method, payload: {} },
+  });
+  try {
+    const response = await route.fetch(request(envelope('inventory')));
+    const body = await response.json();
+    check('inventory answers', body && body.result && body.result.ok === true, JSON.stringify(body).slice(0, 160));
+    check('inventory rev matches graph', body.result.value.rev === 'rev-test', body.result.value && body.result.value.rev);
+    check('inventory ids', Array.isArray(body.result.value.ids) && body.result.value.ids.join() === 'a,b');
+  } catch (error) {
+    check('inventory answers', false, error.message);
+  }
+  try {
+    const response = await route.fetch(request(envelope('report')));
+    check('report answers', response.ok === true);
+  } catch (error) {
+    check('report answers', false, error.message);
+  }
+  try {
+    const response = await route.fetch({
+      method: 'POST',
+      headers: new Headers({ host: 'example.com', 'content-type': 'application/json' }),
+      text: async () => JSON.stringify(envelope('inventory')),
+    });
+    check('non-loopback refused', response.status === 403, String(response.status));
+  } catch (error) {
+    check('non-loopback refused', false, error.message);
+  }
+
+  // Same machine, different port: a dev server page must not rewrite the store.
+  const foreign = [
+    ['other port refused', { origin: 'http://127.0.0.1:3000' }],
+    ['same-site fetch refused', { 'sec-fetch-site': 'same-site' }],
+  ];
+  for (const [label, headers] of foreign) {
+    try {
+      const response = await route.fetch(request(envelope('inventory'), headers));
+      check(label, response.status === 403, String(response.status));
+    } catch (error) {
+      check(label, false, error.message);
+    }
+  }
+  // The desktop shell serves the page from a custom protocol; that one must pass.
+  try {
+    const response = await route.fetch(request(envelope('inventory'), { origin: 'dsh-app://app' }));
+    const body = await response.json();
+    check('custom-protocol page allowed', response.ok === true && body.result && body.result.ok === true);
+  } catch (error) {
+    check('custom-protocol page allowed', false, error.message);
+  }
+  // An oversized body is refused before it is parsed.
+  try {
+    const huge = request(envelope('inventory'));
+    huge.text = async () => 'x'.repeat(300 * 1024);
+    const response = await route.fetch(huge);
+    check('oversized body refused', response.status === 413, String(response.status));
+  } catch (error) {
+    check('oversized body refused', false, error.message);
+  }
+}
+
+for (const dispose of effects) {
+  if (typeof dispose === 'function') {
+    try {
+      dispose();
+    } catch (error) {
+      check('dispose() survived', false, error.message);
+    }
+  }
+}
+
+globalThis.setTimeout = realSetTimeout;
+console.log(failures.length === 0 ? 'PASS' : `FAIL (${failures.length})`);
+process.exit(failures.length === 0 ? 0 : 1);

package/scripts/profile-doctor.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/**
+ * Checks one DSH profile for the configuration that crashes it at startup.
+ *
+ * A bundle listed in `dsh.profile.bundles` whose package cannot be resolved is
+ * fatal: the Host loads bundles in order and the failure happens outside any
+ * per-plugin error boundary. The same is true of a half-installed plugin —
+ * a name in `bundles` without the matching `dependencies` entry and
+ * `node_modules` link.
+ *
+ * Usage:
+ *   node scripts/profile-doctor.mjs                     # every profile
+ *   node scripts/profile-doctor.mjs --profile <dir>     # one profile
+ *   node scripts/profile-doctor.mjs --json
+ *
+ * Exit code 0 means every bundle resolves; 1 means at least one problem.
+ */
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const args = process.argv.slice(2);
+const json = args.includes('--json');
+const profileFlag = args.indexOf('--profile');
+const requested = profileFlag >= 0 ? args[profileFlag + 1] : '';
+
+const profilesRoot = join(homedir(), '.dsh', 'profiles');
+
+function profileDirs() {
+  if (requested) return [requested];
+  if (!existsSync(profilesRoot)) return [];
+  return readdirSync(profilesRoot)
+    .map((name) => join(profilesRoot, name))
+    .filter((dir) => existsSync(join(dir, 'package.json')));
+}
+
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function inspect(dir) {
+  const manifestPath = join(dir, 'package.json');
+  const manifest = readJson(manifestPath);
+  if (!manifest) return { dir, error: `${manifestPath} is not readable JSON` };
+
+  const bundles = manifest?.dsh?.profile?.bundles;
+  if (!Array.isArray(bundles)) return { dir, error: 'dsh.profile.bundles is not an array' };
+
+  const declared = manifest.dependencies || {};
+  const problems = [];
+  const warnings = [];
+  const seen = new Set();
+
+  for (const name of bundles) {
+    if (typeof name !== 'string' || !name) {
+      problems.push({ kind: 'bad-entry', name: String(name), detail: 'bundle name is not a string' });
+      continue;
+    }
+    if (seen.has(name)) problems.push({ kind: 'duplicate', name, detail: 'listed more than once' });
+    seen.add(name);
+
+    const pkgDir = join(dir, 'node_modules', name);
+    if (!existsSync(pkgDir)) {
+      // Plugins that ship inside the app never appear in node_modules. Only a
+      // declared dependency that is not installed is a half-finished install.
+      if (declared[name] === undefined) {
+        warnings.push({
+          kind: 'not-in-profile',
+          name,
+          detail: 'not installed in this profile — assumed to ship with the app',
+        });
+      } else {
+        problems.push({
+          kind: 'missing-link',
+          name,
+          detail: 'dependency is declared but node_modules has no link for it',
+        });
+      }
+      continue;
+    }
+
+    const entry = join(pkgDir, 'package.json');
+    if (!existsSync(entry)) {
+      problems.push({ kind: 'missing-manifest', name, detail: `${entry} does not exist` });
+      continue;
+    }
+    const pkg = readJson(entry);
+    if (!pkg) {
+      problems.push({ kind: 'broken-manifest', name, detail: `${entry} is not readable JSON` });
+      continue;
+    }
+    if (pkg.name !== name) {
+      problems.push({ kind: 'name-mismatch', name, detail: `package.json says "${pkg.name}"` });
+    }
+    try {
+      statSync(realpathSync(pkgDir));
+    } catch {
+      problems.push({ kind: 'broken-link', name, detail: 'node_modules link points at a missing directory' });
+    }
+  }
+
+  for (const [name, spec] of Object.entries(declared)) {
+    if (typeof spec === 'string' && spec.startsWith('link:') && !existsSync(spec.slice(5))) {
+      problems.push({ kind: 'dangling-dependency', name, detail: `${spec} does not exist` });
+    }
+  }
+
+  return { dir, bundles: bundles.length, problems, warnings };
+}
+
+const reports = profileDirs().map((dir) => {
+  try {
+    return inspect(dir);
+  } catch (error) {
+    return { dir, error: (error && error.message) || String(error) };
+  }
+});
+
+if (json) {
+  process.stdout.write(`${JSON.stringify(reports, null, 2)}\n`);
+} else {
+  for (const report of reports) {
+    if (report.error) {
+      console.log(`FAIL ${report.dir}\n  ${report.error}`);
+      continue;
+    }
+    const ok = report.problems.length === 0;
+    console.log(`${ok ? 'ok  ' : 'FAIL'} ${report.dir} — ${report.bundles} bundle(s)`);
+    for (const problem of report.problems) {
+      console.log(`  - ${problem.kind}: ${problem.name} — ${problem.detail}`);
+    }
+    for (const warning of report.warnings || []) {
+      console.log(`  . ${warning.kind}: ${warning.name} — ${warning.detail}`);
+    }
+  }
+}
+
+const failed = reports.some((report) => report.error || report.problems?.length);
+if (!reports.length) {
+  console.log('no profile found');
+}
+process.exit(failed ? 1 : 0);