dsh-panel-control 0.3.12 → 0.3.13

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-panel-control",
-  "version": "0.3.12",
+  "version": "0.3.13",
   "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": [
@@ -24,7 +24,8 @@
     "docs",
     "icon.svg",
     "index.js",
-    "screenshots.json"
+    "screenshots.json",
+    "scripts"
   ],
   "dsh": {
     "bundle": {

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);