dsh-toolfold 0.1.8 → 0.1.10

package/lib/index.js

@@ -1,137 +1,395 @@
+import { createRequire } from "node:module";
+import z from "schemastery";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+//#region src/host/version.js
 /**
- * dsh-toolfold — HOST half.
- *
- * Registers the `toolfold` settings namespace in the DSH settings service
- * (persisted in `~/.dsh/settings.yaml`, the same document every product and
- * family plugin uses) and serves the browser half through one same-origin
- * JSON route:
- *
- *   GET  /api/dsh-toolfold/settings → { ok, value: { value, revision, writable } }
- *   POST /api/dsh-toolfold/settings → body { op: 'set'|'unset', field, value?,
- *                                      expectedRevision? }
- *                                   → { ok, value: { value, revision, writable } }
- *
- * The browser half prefers the official `settingsScope` transport when the
- * deployment exposes this namespace, then this route, then browser
- * localStorage as a degraded fallback. `value` is always the fully resolved
- * section (schema defaults + composition base + the user's settings.yaml
- * overrides), so the client never re-implements the resolution.
- *
- * The same package also declares `dsh.bundle.patch` (see cordis.patch.yml),
- * which makes `dsh plugin --profile <name> add <this package>` install AND
- * mount both halves in one command.
- */
-import { settingsNamespace } from '@deepseek-ai/dsh-settings'
-import z from 'schemastery'
-
-export const name = 'toolfold'
-export const inject = ['settings', 'webServer']
-
-const NS = settingsNamespace('toolfold')
-const API_PATH = '/api/dsh-toolfold/settings'
-const FIELDS = ['durMs', 'keepThink', 'splitThink', 'stats']
-
+* dsh-toolfold — version-range helpers (host side, zero dependencies).
+*
+* The single source of truth for the supported DSH product range is this
+* package's own `engines.dsh` field (an npm-style range such as
+* ">=0.1.2-rc.1 <0.1.3 || >=0.1.5-rc.1 <0.1.6"). The build stamps that
+* field into the host artifact via tsdown `define` (__DSH_ENGINES__, see
+* tsdown.config.mjs) and the host half judges the running DSH with the
+* matcher below — no range is hardcoded anywhere, so widening support is
+* a one-line package.json edit + rebuild.
+*
+* Supported range grammar (the subset npm engines ranges actually use):
+*   range      := branch ("||" branch)*
+*   branch     := comparator ((" " | ",") comparator)*
+*   comparator := (">=" | "<=" | ">" | "<" | "=" | "==")? version
+* A bare version means "=". Anything else (caret/tilde/x-ranges, hyphen
+* ranges, junk) invalidates its branch; a range with no valid branch
+* matches nothing and the caller reports 'unknown' instead of crying wolf.
+*
+* Prerelease gating follows npm semver: a prerelease running version only
+* satisfies a branch that names a prerelease on the same
+* [major, minor, patch] tuple (e.g. 0.1.5-rc.1 satisfies
+* ">=0.1.5-rc.1 <0.1.6", but 0.1.3-rc.1 does NOT satisfy
+* ">=0.1.2-rc.1 <0.1.3").
+*/
+/** Parse "v1.2.3-rc.4+build" into comparable parts; null on junk. */
+function parseVersion(value) {
+	const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(String(value));
+	if (!match) return null;
+	return {
+		core: [
+			Number(match[1]),
+			Number(match[2]),
+			Number(match[3])
+		],
+		pre: match[4] === void 0 ? null : match[4].split(".")
+	};
+}
+/** Compare two parsed versions (semver precedence, prerelease-aware): -1/0/1. */
+function compareParsed(a, b) {
+	for (let i = 0; i < 3; i++) if (a.core[i] !== b.core[i]) return a.core[i] < b.core[i] ? -1 : 1;
+	if (a.pre === null && b.pre === null) return 0;
+	if (a.pre === null) return 1;
+	if (b.pre === null) return -1;
+	const len = Math.max(a.pre.length, b.pre.length);
+	for (let i = 0; i < len; i++) {
+		const x = a.pre[i];
+		const y = b.pre[i];
+		if (x === void 0) return -1;
+		if (y === void 0) return 1;
+		const xn = /^\d+$/.test(x);
+		const yn = /^\d+$/.test(y);
+		if (xn && yn) {
+			const dx = Number(x);
+			const dy = Number(y);
+			if (dx !== dy) return dx < dy ? -1 : 1;
+		} else if (xn !== yn) return xn ? -1 : 1;
+		else if (x !== y) return x < y ? -1 : 1;
+	}
+	return 0;
+}
+/**
+* Parse one "||" branch into comparators; null when the branch is unusable.
+* The operator may be separated from its version by whitespace (npm
+* semver tolerates ">= 1.2.3"), so comparators are matched globally and
+* the gaps between matches must contain only whitespace/commas — anything
+* else invalidates the branch.
+*/
+function parseBranch(text) {
+	const src = String(text).trim();
+	if (src === "") return null;
+	const re = /(>=|<=|>|<|==|=)?\s*(v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)/g;
+	const comps = [];
+	let pos = 0;
+	let m;
+	while ((m = re.exec(src)) !== null) {
+		if (m[0] === "") {
+			re.lastIndex++;
+			continue;
+		}
+		if (!/^[\s,]*$/.test(src.slice(pos, m.index))) return null;
+		const v = parseVersion(m[2]);
+		if (v === null) return null;
+		comps.push({
+			op: m[1] === void 0 || m[1] === "==" ? "=" : m[1],
+			v
+		});
+		pos = m.index + m[0].length;
+	}
+	if (!/^[\s,]*$/.test(src.slice(pos))) return null;
+	return comps.length === 0 ? null : comps;
+}
+/** Parse a full range string into its valid branches; [] when unusable. */
+function parseEnginesRange(rangeStr) {
+	if (typeof rangeStr !== "string") return [];
+	const branches = [];
+	for (const part of rangeStr.split("||")) {
+		const comps = parseBranch(part.trim());
+		if (comps !== null) branches.push(comps);
+	}
+	return branches;
+}
+function testComp(op, cmp) {
+	switch (op) {
+		case ">=": return cmp >= 0;
+		case "<=": return cmp <= 0;
+		case ">": return cmp > 0;
+		case "<": return cmp < 0;
+		default: return cmp === 0;
+	}
+}
+function sameCore(a, b) {
+	return a.core[0] === b.core[0] && a.core[1] === b.core[1] && a.core[2] === b.core[2];
+}
+/** npm semver prerelease gate for one branch. */
+function gateOk(comps, ver) {
+	if (ver.pre === null) return true;
+	return comps.some((c) => c.v.pre !== null && sameCore(c.v, ver));
+}
+/** True when the parsed version satisfies at least one branch. */
+function satisfiesEngines(parsed, branches) {
+	for (const comps of branches) {
+		let ok = true;
+		for (const c of comps) if (!testComp(c.op, compareParsed(parsed, c.v))) {
+			ok = false;
+			break;
+		}
+		if (ok && gateOk(comps, parsed)) return true;
+	}
+	return false;
+}
+/** Lowest lower bound across all branches (>=, >, =); null when unbounded. */
+function lowestFloor(branches) {
+	let floor = null;
+	for (const comps of branches) for (const c of comps) if (c.op === ">=" || c.op === ">" || c.op === "=") {
+		if (floor === null || compareParsed(c.v, floor) < 0) floor = c.v;
+	}
+	return floor;
+}
+/**
+* Judge a running version against a raw engines range string:
+* 'ok' | 'old' | 'new' | 'unknown'. Never throws. Below every supported
+* floor → 'old'; outside anywhere else (including between "||" gaps) →
+* 'new'; unusable input on either side → 'unknown' (fail silent, never
+* false-alarm).
+*/
+function compatFor(version, rangeStr) {
+	const parsed = parseVersion(version);
+	if (parsed === null) return "unknown";
+	const branches = parseEnginesRange(rangeStr);
+	if (branches.length === 0) return "unknown";
+	if (satisfiesEngines(parsed, branches)) return "ok";
+	const floor = lowestFloor(branches);
+	if (floor !== null && compareParsed(parsed, floor) < 0) return "old";
+	return "new";
+}
+//#endregion
+//#region src/host/index.js
+/**
+* dsh-toolfold — HOST half.
+*
+* Registers the `toolfold` settings namespace in the DSH settings service
+* (persisted in `~/.dsh/settings.yaml`, the same document every product and
+* family plugin uses) and serves the browser half through one same-origin
+* JSON route:
+*
+*   GET  /api/dsh-toolfold/settings → { ok, value: { value, revision, writable } }
+*   POST /api/dsh-toolfold/settings → body { op: 'set'|'unset', field, value?,
+*                                      expectedRevision? }
+*                                   → { ok, value: { value, revision, writable } }
+*
+* Every success response additionally carries `dsh: { version, state, range }` —
+* the running DSH product version, its compatibility with the supported
+* range ('ok' | 'old' | 'new' | 'unknown'), and the raw `engines.dsh`
+* requirement the verdict was judged against. DSH does not enforce
+* `engines.dsh` anywhere, so the host half reports the mismatch itself
+* and the settings card warns the user (once-only console warning +
+* hover-tip icon quoting the live range).
+*
+* The browser half prefers the official `settingsScope` transport when the
+* deployment exposes this namespace, then this route, then browser
+* localStorage as a degraded fallback. `value` is always the fully resolved
+* section (schema defaults + composition base + the user's settings.yaml
+* overrides), so the client never re-implements the resolution.
+*
+* The same package also declares `dsh.bundle.patch` (see cordis.patch.yml),
+* which makes `dsh plugin --profile <name> add <this package>` install AND
+* mount both halves in one command.
+*/
+const name = "toolfold";
+const inject = ["settings", "webServer"];
+const NS = "toolfold";
+const API_PATH = "/api/dsh-toolfold/settings";
+const FIELDS = [
+	"enabled",
+	"durMs",
+	"thinkMode",
+	"keepThink",
+	"thinkAuto",
+	"splitThink",
+	"stats"
+];
 const SCHEMA = z.object({
-  durMs: z.number().step(10).min(0).max(2000).default(240),
-  keepThink: z.boolean().default(false),
-  splitThink: z.boolean().default(true),
-  stats: z.boolean().default(false),
-})
-
+	enabled: z.boolean().default(true),
+	durMs: z.number().step(10).min(0).max(2e3).default(240),
+	thinkMode: z.union([
+		z.const("auto"),
+		z.const("keep"),
+		z.const("hide")
+	]),
+	keepThink: z.boolean().default(false),
+	thinkAuto: z.boolean().default(true),
+	splitThink: z.boolean().default(true),
+	stats: z.boolean().default(false)
+});
+/**
+* Resolve the canonical think mode for one section. An explicitly set,
+* valid thinkMode wins; otherwise derive it from the deprecated keys so
+* pre-merge preferences survive the upgrade; default 'auto'. Total —
+* never throws. (Client twin: resolveThinkMode in src/client/settings.js.)
+*/
+function resolveThinkMode(section) {
+	var mode = section !== void 0 && section !== null ? section.thinkMode : void 0;
+	if (mode === "keep" || mode === "hide" || mode === "auto") return mode;
+	if (section !== void 0 && section !== null && section.thinkAuto === false) return section.keepThink === true ? "keep" : "hide";
+	return "auto";
+}
+const ENGINES_RANGE = ">=0.1.2-rc.1 <0.1.3 || >=0.1.5-rc.1 <0.1.6";
+/**
+* The @deepseek-ai/dsh version this process was launched from: process.argv[1]
+* is the CLI's entry, and module resolution from that file reaches the
+* @deepseek-ai/dsh package.json it belongs to. Null when undetectable
+* (workers, dev launchers without a resolvable package).
+*/
+let cachedDshVersion;
+function dshVersion() {
+	if (cachedDshVersion !== void 0) return cachedDshVersion;
+	cachedDshVersion = null;
+	try {
+		const entry = process.argv && process.argv[1];
+		if (!entry) return cachedDshVersion;
+		const pkgPath = createRequire(resolve(entry)).resolve("@deepseek-ai/dsh/package.json");
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+		if (pkg && pkg.name === "@deepseek-ai/dsh" && typeof pkg.version === "string" && pkg.version !== "") cachedDshVersion = pkg.version;
+	} catch (error) {}
+	return cachedDshVersion;
+}
+/**
+* Running DSH vs the supported range (see ./version.js): the report the
+* settings card renders its warning icon from. `range` is the raw
+* `engines.dsh` string so the card can quote the live requirement instead
+* of hardcoding it: { version, state: 'ok'|'old'|'new'|'unknown', range }.
+*/
+function dshCompat() {
+	const version = dshVersion();
+	const range = ENGINES_RANGE;
+	if (version === null || false) return {
+		version,
+		state: "unknown",
+		range
+	};
+	return {
+		version,
+		state: compatFor(version, range),
+		range
+	};
+}
 /** Write one JSON response. */
 function json(res, status, body) {
-  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' })
-  res.end(JSON.stringify(body))
+	res.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+	res.end(JSON.stringify(body));
 }
-
 /** Read a JSON request body (bounded). */
 function readJsonBody(req) {
-  return new Promise((resolve, reject) => {
-    let size = 0
-    const chunks = []
-    req.on('data', (chunk) => {
-      size += chunk.length
-      if (size > 64 * 1024) {
-        reject(new Error('body-too-large'))
-        req.destroy()
-        return
-      }
-      chunks.push(chunk)
-    })
-    req.on('end', () => {
-      if (chunks.length === 0) {
-        resolve({})
-        return
-      }
-      try {
-        resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')))
-      } catch {
-        reject(new Error('invalid-json'))
-      }
-    })
-    req.on('error', reject)
-  })
+	return new Promise((resolve, reject) => {
+		let size = 0;
+		const chunks = [];
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > 65536) {
+				reject(/* @__PURE__ */ new Error("body-too-large"));
+				req.destroy();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			if (chunks.length === 0) {
+				resolve({});
+				return;
+			}
+			try {
+				resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+			} catch {
+				reject(/* @__PURE__ */ new Error("invalid-json"));
+			}
+		});
+		req.on("error", reject);
+	});
 }
-
-export function apply(ctx) {
-  // Fiber-scoped registration: removed when this plugin is stopped/removed.
-  ctx.settings.register(NS, SCHEMA, { base: {} })
-
-  /** Current resolved section + revision + writability, as one JSON view. */
-  const snapshot = () => {
-    let value = ctx.settings.get(NS)
-    let revision
-    for (const descriptor of ctx.settings.describe()) {
-      if (descriptor.ns === NS) {
-        value = descriptor.value
-        revision = descriptor.revision
-        break
-      }
-    }
-    return {
-      ok: true,
-      value: {
-        value,
-        ...(revision === undefined ? {} : { revision }),
-        writable: ctx.settings.writable,
-      },
-    }
-  }
-
-  const handler = (req, res) => {
-    if (req.method === 'GET') {
-      try {
-        json(res, 200, snapshot())
-      } catch (error) {
-        json(res, 500, { ok: false, error: error instanceof Error ? error.message : String(error) })
-      }
-      return
-    }
-    if (req.method === 'POST') {
-      readJsonBody(req).then((body) => {
-        const field = String(body?.field ?? '')
-        if (!FIELDS.includes(field)) {
-          json(res, 400, { ok: false, error: 'invalid-field' })
-          return
-        }
-        const op = body?.op === 'unset' ? 'unset' : 'set'
-        const ops = op === 'unset'
-          ? [{ op: 'unset', path: [field] }]
-          : [{ op: 'set', path: [field], value: body.value }]
-        const expectedRevision = typeof body?.expectedRevision === 'number' ? body.expectedRevision : undefined
-        return ctx.settings.mutate(NS, ops, expectedRevision)
-          .then(() => json(res, 200, snapshot()))
-          .catch((error) => json(res, 400, { ok: false, error: error instanceof Error ? error.message : String(error) }))
-      }, (error) => {
-        json(res, 400, { ok: false, error: error instanceof Error ? error.message : String(error) })
-      })
-      return
-    }
-    json(res, 405, { ok: false, error: 'method-not-allowed' })
-  }
-
-  ctx.effect(() => {
-    const dispose = ctx.webServer.register({ kind: 'exact', path: API_PATH, handler })
-    return () => dispose()
-  })
+function apply(ctx) {
+	ctx.settings.register(NS, SCHEMA, { base: {} });
+	/** Current resolved section + revision + writability, as one JSON view. */
+	const snapshot = () => {
+		let value = ctx.settings.get(NS);
+		let revision;
+		for (const descriptor of ctx.settings.describe()) if (descriptor.ns === NS) {
+			value = descriptor.value;
+			revision = descriptor.revision;
+			break;
+		}
+		return {
+			ok: true,
+			value: {
+				value: {
+					...value,
+					thinkMode: resolveThinkMode(value)
+				},
+				...revision === void 0 ? {} : { revision },
+				writable: ctx.settings.writable
+			}
+		};
+	};
+	const handler = (req, res) => {
+		if (req.method === "GET") {
+			try {
+				json(res, 200, {
+					...snapshot(),
+					dsh: dshCompat()
+				});
+			} catch (error) {
+				json(res, 500, {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+			return;
+		}
+		if (req.method === "POST") {
+			readJsonBody(req).then((body) => {
+				const field = String(body?.field ?? "");
+				if (!FIELDS.includes(field)) {
+					json(res, 400, {
+						ok: false,
+						error: "invalid-field"
+					});
+					return;
+				}
+				const ops = (body?.op === "unset" ? "unset" : "set") === "unset" ? [{
+					op: "unset",
+					path: [field]
+				}] : [{
+					op: "set",
+					path: [field],
+					value: body.value
+				}];
+				const expectedRevision = typeof body?.expectedRevision === "number" ? body.expectedRevision : void 0;
+				return ctx.settings.mutate(NS, ops, expectedRevision).then(() => json(res, 200, {
+					...snapshot(),
+					dsh: dshCompat()
+				})).catch((error) => json(res, 400, {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				}));
+			}, (error) => {
+				json(res, 400, {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			});
+			return;
+		}
+		json(res, 405, {
+			ok: false,
+			error: "method-not-allowed"
+		});
+	};
+	ctx.effect(() => {
+		const dispose = ctx.webServer.register({
+			kind: "exact",
+			path: API_PATH,
+			handler
+		});
+		return () => dispose();
+	});
 }
+//#endregion
+export { apply, inject, name };
+
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-toolfold",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "工具调用与思考的折叠显示：连续工具调用折叠为最后一个调用（可展开），已完成的思考随组折叠（可保留、展开时按原顺序显示），进行中的思考保持独立显示。",
   "repository": {
     "type": "git",
@@ -27,20 +27,31 @@
     }
   },
   "files": [
-    "lib",
+    "lib/index.js",
+    "lib/client.js",
     "cordis.patch.yml",
     "scripts",
     "README.md",
     "README.en.md",
     "CHANGELOG.md"
   ],
+  "engines": {
+    "dsh": ">=0.1.2-rc.1 <0.1.3 || >=0.1.5-rc.1 <0.1.6"
+  },
   "peerDependencies": {
-    "@deepseek-ai/dsh-settings": ">=0.1.0-rc.7 <0.1.1 || >=0.1.1-rc.0 <0.1.2",
     "schemastery": "^3.18.0"
   },
+  "devDependencies": {
+    "jsdom": "29.1.1",
+    "playwright": "1.61.1",
+    "tsdown": "^0.22.2"
+  },
   "license": "MIT",
   "scripts": {
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
     "test:engine": "node tools/engine-smoke.mjs",
+    "test:version": "node tools/version-smoke.mjs",
     "probe:live": "node tools/live-probe.mjs",
     "install:dsh": "node scripts/install-dsh.cjs",
     "uninstall:dsh": "node scripts/install-dsh.cjs uninstall"

package/lib/build-dynamic.cjs

@@ -1,69 +0,0 @@
-/**
- * build-dynamic.js — generate lib/dynamic-body.js (the `code.client` body for
- * cordis_define) from lib/client.js.
- *
- * The dynamic runner wraps the body in `async () => { ... }` and evaluates it
- * in a scope where `React` is a closure parameter, so the body must:
- *   - NOT redeclare `var React` (var hoisting would shadow the closure
- *     parameter and the settings card would silently never render);
- *   - end with `return plugin;` (a bare function body has no exports).
- *
- * Usage: node lib/build-dynamic.js
- */
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const srcPath = path.join(__dirname, 'client.js');
-const outPath = path.join(__dirname, 'dynamic-body.js');
-
-let src = fs.readFileSync(srcPath, 'utf8');
-
-// 1. Extract the factory function body: everything between
-//    "factory: function (require) {" and the final "\n});".
-const factoryMarker = 'factory: function (require) {';
-const start = src.indexOf(factoryMarker);
-if (start === -1) throw new Error('factory marker not found in client.js');
-const bodyStart = start + factoryMarker.length;
-
-const endMarker = '\n});';
-const end = src.lastIndexOf(endMarker);
-if (end === -1) throw new Error('module end marker not found in client.js');
-
-let body = src.slice(bodyStart, end);
-// Drop the factory's own closing brace (the trailing "  }").
-body = body.replace(/\n[ \t]*\}\s*$/, '');
-
-// 2. Remove the CommonJS export boilerplate.
-const boilerplate =
-  '    var module = { exports: {} };\n' +
-  '    var exports = module.exports;\n' +
-  '    Object.defineProperty(exports, Symbol.toStringTag, { value: \'Module\' });\n';
-if (body.indexOf(boilerplate) === -1) throw new Error('module boilerplate not found');
-body = body.replace(boilerplate, '');
-
-// 3. Replace the React require block with an explanatory comment (see header).
-const reactBlock =
-  '    // React is a platform seed word in the web shell; the settings card\n' +
-  '    // needs it, the folding engine does not.\n' +
-  '    var React = null;\n' +
-  '    try {\n' +
-  '      React = require(\'react\');\n' +
-  '    } catch (err) {\n' +
-  '      React = null;\n' +
-  '    }\n';
-if (body.indexOf(reactBlock) === -1) throw new Error('React block not found');
-body = body.replace(reactBlock,
-  '    // React is the runner\'s closure parameter; the folding engine does not\n' +
-  '    // need it directly, and redeclaring it here would shadow the parameter.\n');
-
-// 4. Replace the module.exports tail with a bare `return plugin;`.
-const tail =
-  '    module.exports = plugin;\n' +
-  '    return module.exports;';
-if (body.indexOf(tail) === -1) throw new Error('export tail not found');
-body = body.replace(tail, 'return plugin;\n');
-
-fs.writeFileSync(outPath, body, 'utf8');
-console.log('wrote', outPath, body.length, 'bytes');