dsh-plugin-toolkit 0.8.0 → 0.8.2

package/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 0.8.2
+
+`doctor` now refuses the failure that shipped in 0.8.0.
+
+- New check `root export`: when a package declares `dsh.bundle`, its root module
+  has to be the plugin. A root that is also a `bin` target — a CLI wearing a
+  plugin's clothes — is reported, and so is a root module with no `apply`.
+  pnpm reports success either way; the row just mounts nothing.
+- `test/doctor.test.mjs` covers both shapes, and a bundle with no root module
+  (a subpath plugin) stays legal.
+
+## 0.8.1
+
+`0.8.0` installed and then did nothing: the loader starts a plugin by importing
+the bare package name, and `exports["."]` still pointed at the CLI, so the row
+had no `apply` to run.
+
+- `exports["."]` is `./index.js`; the CLI keeps `./cli` and `bin`, the testkit
+  keeps `./testkit`.
+- `test/entry.test.mjs` guards the shape: the root export is the plugin, the
+  patch file names the package once as `- insert:`, and every path
+  `package.json` points at is in `files`.
+
 ## 0.8.0
 
 The toolkit can now be installed as a plugin, because a tool that cannot be

package/README.md

@@ -18,6 +18,15 @@ npx dsh-plugin-toolkit@0.7.0 release --pr --merge              # tag, wait for n
 | changing a panel that is already installed | [`dev`](#2-develop-a-panel) | `mount`, the testkit |
 | shipping a version | [`verify`](#3-ship-a-version) | `release`, `index` |
 
+It also installs as a plugin. `dsh plugin add dsh-plugin-toolkit` adds a
+**Plugin doctor** tab to the right sidebar: name the folder that holds a
+plugin's `package.json`, and it runs the same checks `verify` runs and lists
+what would fail — the same answers as the CLI, without leaving the app.
+
+```
+$ dsh plugin add dsh-plugin-toolkit
+```
+
 ### 1. Write a plugin
 
 [`init`](#start-from-a-plugin-that-already-passes) writes the files whose absence shows up as a failed first publish — `engines.dsh`, the patch file, a `files` list that ships the code, a client bundle, a test for it, and the CI that runs both. `doctor` then checks the same things without writing anything, and [`verify`](#prove-the-tarball-works-not-just-the-repository) checks the tarball instead of the working copy.

package/lib/doctor.mjs

@@ -138,6 +138,34 @@ export function checkFilesList(manifest) {
   return null;
 }
 
+/**
+ * The loader starts a plugin by importing the bare package name. A package that
+ * ships both a CLI and a panel is one `exports` edit away from having its root
+ * point at the CLI — the row then mounts nothing, and pnpm reports success.
+ */
+export function checkRootExport(dir, manifest) {
+  if (manifest.dsh === undefined || manifest.dsh === null) return null;
+  const root = typeof manifest.exports === 'object' && manifest.exports !== null ? manifest.exports['.'] : undefined;
+  const entry = typeof root === 'string' ? root : manifest.main;
+  // A bundle that inserts a subpath plugin needs no root module at all.
+  if (typeof entry !== 'string') return null;
+
+  const target = entry.replace(/^\.\//, '');
+  const bins = Object.values(manifest.bin ?? {}).filter((value) => typeof value === 'string');
+  if (bins.some((bin) => bin.replace(/^\.\//, '') === target) === true) {
+    return `exports["."] points at the CLI (${entry}), so the loader's row has no plugin to apply; point it at the module that exports apply`;
+  }
+
+  const file = path.resolve(dir, target);
+  if (fs.existsSync(file) === false) return null;
+  const source = fs.readFileSync(file, 'utf8');
+  const exported = /export\s+(?:async\s+)?function\s+apply\b|export\s+(?:const|let|var)\s+apply\b|export\s*\{[^}]*\bapply\b|\bapply\s*[:=]\s*(?:async\s*)?(?:function|\()/.test(source);
+  if (exported === false) {
+    return `the root export ${entry} does not export apply, so the loader imports the package and mounts nothing`;
+  }
+  return null;
+}
+
 /** Runs every check and returns `{ failures, notes }`. */
 export function doctor(dir) {
   const { manifest } = readManifest(dir);
@@ -149,6 +177,7 @@ export function doctor(dir) {
     ['patch file', checkPatchFile(dir, manifest)],
     ['client entry', checkClientEntry(dir, manifest)],
     ['files list', checkFilesList(manifest)],
+    ['root export', checkRootExport(dir, manifest)],
   ];
   const failures = checks.filter(([, result]) => result !== null && typeof result === 'string');
   return {

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "dsh-plugin-toolkit",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Preflight, release and test DeepSeek Harness plugins: checks what the host needs, waits for npm to actually serve the version, and keeps the market index honest.",
   "type": "module",
   "bin": {
     "dsh-plugin": "bin/dsh-plugin.mjs"
   },
   "exports": {
-    ".": "./lib/cli.mjs",
+    ".": "./index.js",
+    "./cli": "./lib/cli.mjs",
     "./testkit": "./lib/testkit/index.mjs"
   },
   "files": [
@@ -74,5 +75,6 @@
     "bundle": {
       "patch": "./cordis.patch.yml"
     }
-  }
+  },
+  "main": "index.js"
 }