dsh-panel-control 0.3.16 → 0.7.1

package/scripts/host-smoke.mjs

@@ -29,6 +29,9 @@ const MODULE = pathToFileURL(override ? path.resolve(override) : path.join(here,
 // 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';
+// Rescue-by-current-revision is an explicit opt-in now: the pages below exercise
+// it deliberately, while the default path is asserted later.
+process.env.DPC_SERVE_CURRENT = 'on';
 
 const timers = [];
 const realSetTimeout = globalThis.setTimeout;
@@ -62,6 +65,10 @@ const clientModulesStub = {
       { id: 'a' },
       { id: 'b' },
       { id: 'dsh-panel-control', rev: 'rev-now', url: 'plugins/??dsh-panel-control/client.js&rev=rev-now' },
+      // The plugin that sits next to this one in the real profile: it carries no
+      // fallback of its own, so a retired revision used to drop it silently
+      // while the manager still reported it running.
+      { id: 'dsh-workspace-control', rev: 'rev-now', url: 'plugins/??dsh-workspace-control/client.js&rev=rev-now' },
     ],
     batches: [],
   }),
@@ -195,6 +202,19 @@ if (route) {
       '/plugins/??dsh-panel-control/client.js&rev=rev-old',
     );
     check('stale revision is served at the current one', stale.status === 200, `status ${stale.status}`);
+    // A combo is the batch the page booted with. Answering it with this one
+    // module's bytes registers this plugin and silently drops every other module
+    // in the batch -- the page then runs one plugin instead of the list it
+    // booted with. The stale combo has to stay a 404.
+    const staleCombo = await clientModulesStub.bundleResource(
+      'GET',
+      '/plugins/??a/client.js,b/client.js,dsh-panel-control/client.js&rev=rev-old-combo',
+    );
+    check(
+      'a stale combo is not answered with the single bundle',
+      staleCombo.status === 404,
+      `status ${staleCombo.status}`,
+    );
     // A revision this Host already handed out must survive the registry
     // forgetting it: the page keeps asking for the list it booted with.
     await clientModulesStub.bundleResource('GET', '/plugins/??dsh-panel-control/client.js&rev=rev-now');
@@ -211,11 +231,23 @@ if (route) {
     );
     check('current revision passes straight through', fresh.status === 200, `status ${fresh.status}`);
     const other = await clientModulesStub.bundleResource('GET', '/plugins/??someone-else/client.js&rev=old');
-    check('other packages keep their 404', other.status === 404, `status ${other.status}`);
+    check('packages outside the graph keep their 404', other.status === 404, `status ${other.status}`);
+    // The reported bug: a *neighbouring* plugin on a retired revision. Our
+    // bundle loaded, theirs 404'd, and it vanished from the page while the
+    // manager kept saying "running". One fallback for the whole list fixes it.
+    const neighbour = await clientModulesStub.bundleResource(
+      'GET',
+      '/plugins/??dsh-workspace-control/client.js&rev=rev-old',
+    );
+    check(
+      'a neighbouring plugin is served at the current revision too',
+      neighbour.status === 200,
+      `status ${neighbour.status}`
+    );
     check(
       'inventory ids',
       Array.isArray(body.result.value.ids) &&
-        body.result.value.ids.join() === 'a,b,dsh-panel-control',
+        body.result.value.ids.join() === 'a,b,dsh-panel-control,dsh-workspace-control',
       body.result.value && body.result.value.ids.join(),
     );
   } catch (error) {
@@ -259,6 +291,17 @@ if (route) {
   } catch (error) {
     check('custom-protocol page allowed', false, error.message);
   }
+  // The desktop dev-proxy serves the page from a reserved .invalid origin; the
+  // page is still ours, so its calls must not be refused.
+  try {
+    const response = await route.fetch(
+      request(envelope('inventory'), { host: 'unlag.invalid', origin: 'http://unlag.invalid' }),
+    );
+    const body = await response.json();
+    check('dev-proxy page allowed', response.ok === true && body.result && body.result.ok === true, String(response.status));
+  } catch (error) {
+    check('dev-proxy page allowed', false, error.message);
+  }
   // An oversized body is refused before it is parsed.
   try {
     const huge = request(envelope('inventory'));

package/scripts/layout-smoke.mjs

@@ -0,0 +1,48 @@
+// Static gate for the sidebar layout guard (discussion #12083).
+//
+// The guard is CSS plus a handful of attributes the engine writes; neither is
+// reachable from a node unit test because client.js only loads inside the page
+// module loader. These assertions keep the pieces the runtime check proved are
+// necessary from silently disappearing in a refactor.
+import { readFileSync } from 'node:fs';
+
+const read = (name) => readFileSync(new URL('../' + name, import.meta.url), 'utf8');
+const client = read('client.js');
+const pkg = JSON.parse(read('package.json'));
+const problems = [];
+
+const expect = (ok, message) => {
+  if (!ok) problems.push(message);
+};
+
+for (const marker of [
+  'data-dpc-list',
+  'data-dpc-unbounded',
+  'data-dpc-region',
+  '--dpc-panellist-max',
+  'data-dpc-group-id',
+  'dpc-caret',
+  'dpc-sepCount',
+  'layoutTitle',
+  'layoutGuard',
+  'layoutMaxNone',
+  'toggleCollapse',
+]) {
+  expect(client.includes(marker), 'client.js lost ' + marker);
+}
+
+expect(client.includes("const BUILD_STAMP = 'dsh-panel-control/" + pkg.version + "'"), 'BUILD_STAMP and package.json version disagree');
+expect(pkg.scripts && String(pkg.scripts.check).includes('layout-smoke'), 'npm run check no longer runs this gate');
+expect(/\[data-dpc-list\]\{[^}]*overflow-y:auto/.test(client), 'the panel list is not scrollable');
+expect(/\[data-dpc-list\]\{[^}]*max-height:max\(120px,var\(--dpc-panellist-max,45vh\)\)/.test(client), 'the panel list lost its height cap');
+expect(/\[data-dpc-region\]\{[^}]*min-height/.test(client), 'the region below the list lost its floor');
+
+expect(/\.dpc-layoutRow:first-of-type\{[^}]*border-top:0/.test(client), 'the first layout row has a hairline touching the card hint');
+expect(/\.dpc-layout > \.dpc-note\{[^}]*margin:6px 0 10px/.test(client), 'the card hint lost its gap above the rows');
+expect(/\.dpc-layoutActions\{[^}]*margin-top:12px/.test(client), 'the collapse/expand actions lost their separation');
+if (problems.length) {
+  console.error('layout-smoke: ' + problems.length + ' problem(s)');
+  for (const problem of problems) console.error(' - ' + problem);
+  process.exit(1);
+}
+console.log('layout-smoke: ok (' + pkg.version + ')');

package/scripts/read-page-trace.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+/**
+ * Read the page-side trace this plugin leaves in the renderer's localStorage.
+ *
+ * The Host never hears from the Client half when the runner does not apply it,
+ * so the trace is written by the bundle's own module scope and picked up here,
+ * offline, straight out of Chromium's Local Storage LevelDB. No browser, no
+ * DevTools, no waiting on a person to read a window title.
+ *
+ * Usage: node scripts/read-page-trace.mjs [--out <file>]
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const KEY = 'dsh.panel-control.trace';
+const ROAMING = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+const PROFILE = path.join(ROAMING, '@deepseek-ai', 'dsh-desktop', 'Local Storage', 'leveldb');
+const OUT = (() => {
+  const at = process.argv.indexOf('--out');
+  return at !== -1 ? process.argv[at + 1] : path.join(process.env.USERPROFILE || os.homedir(), '.dsh', 'panel-control', 'page-trace.log');
+})();
+
+function printable(text) {
+  return text.replace(/[^\x20-\x7e\u4e00-\u9fff]/g, ' ').replace(/ {2,}/g, ' ').trim();
+}
+
+const found = [];
+let files = [];
+try {
+  files = fs.readdirSync(PROFILE).filter((name) => /\.(log|ldb)$/.test(name));
+} catch (error) {
+  console.error('cannot read', PROFILE, error.message);
+  process.exit(1);
+}
+
+for (const name of files) {
+  const buf = fs.readFileSync(path.join(PROFILE, name));
+  // keys are UTF-8, values are UTF-16LE: read the key to confirm the entry, then
+  // decode the UTF-16LE value that carries the stage list.
+  const keyAt = buf.toString('latin1').indexOf(KEY);
+  const needle = Buffer.from('#ml=', 'utf16le');
+  let value = '';
+  let at = buf.indexOf(needle);
+  while (at !== -1) {
+    const slice = buf.subarray(Math.max(0, at - 800), at + 1600);
+    value += printable(slice.toString('utf16le')) + '\n';
+    at = buf.indexOf(needle, at + 1);
+  }
+  if (keyAt !== -1 || value) found.push({ name, keyAt, value: value.trim() });
+}
+
+// The full boot manifest sits under its own key; it is the only place that says
+// whether the page was handed the same module twice.
+const bootNeedle = Buffer.from('"dupes":', 'utf16le');
+const boots = [];
+for (const name of files) {
+  const buf = fs.readFileSync(path.join(PROFILE, name));
+  let at = buf.indexOf(bootNeedle);
+  while (at !== -1) {
+    const text = printable(buf.subarray(Math.max(0, at - 120), at + 9000).toString('utf16le')).trim();
+    if (text) boots.push(text);
+    at = buf.indexOf(bootNeedle, at + 1);
+  }
+}
+
+// Small always-fresh record: "DPCPAGE|" is written on every stage and on every
+// page error, so at least one copy stays in the live (uncompressed) log file.
+const pageNeedle = Buffer.from('DPCPAGE|', 'utf16le');
+const notes = [];
+for (const name of files) {
+  const buf = fs.readFileSync(path.join(PROFILE, name));
+  let at = buf.indexOf(pageNeedle);
+  while (at !== -1) {
+    const text = printable(buf.subarray(at, at + 4000).toString('utf16le'));
+    if (text) notes.push(`${name}: ${text}`);
+    at = buf.indexOf(pageNeedle, at + 1);
+  }
+}
+const lines = [];
+lines.push(`read ${new Date().toISOString()} from ${PROFILE}`);
+lines.push(`files: ${files.join(' ')}`);
+if (found.length === 0) {
+  lines.push(`no "${KEY}" entry: the bundle's module scope never ran in that page`);
+} else {
+  for (const item of found) {
+    lines.push('');
+    lines.push(`== ${item.name} (key at ${item.keyAt})`);
+    lines.push(item.value || '(key present, value unreadable)');
+  }
+}
+fs.mkdirSync(path.dirname(OUT), { recursive: true });
+// BOOT KEY: "dsh.panel-control.trace.boot"
+lines.push('');
+lines.push('== page note');
+if (notes.length === 0) lines.push('none');
+else lines.push(notes.join('\n---\n'));
+lines.push('');
+lines.push('== boot dump');
+if (boots.length === 0) lines.push('no boot dump: the bundle never described one');
+else lines.push(boots.join('\n---\n'));
+fs.writeFileSync(OUT, lines.join('\n') + '\n', 'utf8');
+console.log(lines.join('\n'));
+console.log('\nwritten to', OUT);