@shidesheng0218/dsh-plugin-lint 0.1.0 → 0.4.0

package/src/core/semver.js

@@ -0,0 +1,192 @@
+/**
+ * A deliberately small semver range evaluator for DSH peer admission.
+ *
+ * The host calls `semver.satisfies(runtime, range, { includePrerelease: true })`
+ * (dsh-app-boot README: "prereleases participate in range matching"). This
+ * module implements the subset of node-semver that appears in plugin peer
+ * declarations: exact/partial versions, = > >= < <=, ^, ~, hyphen ranges, x/*,
+ * and ||. Anything outside that grammar returns 'unknown' instead of guessing:
+ * a rule that cannot decide must not produce an error.
+ */
+
+const VERSION_RE = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/;
+const PARTIAL_RE = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?$/;
+
+export function parseVersion(text) {
+  const match = VERSION_RE.exec(String(text ?? '').trim());
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split('.') : [],
+  };
+}
+
+function compareIdentifiers(a, b) {
+  const aNumeric = /^\d+$/.test(a);
+  const bNumeric = /^\d+$/.test(b);
+  if (aNumeric && bNumeric) return Math.sign(Number(a) - Number(b));
+  if (aNumeric) return -1;
+  if (bNumeric) return 1;
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+export function compareVersions(a, b) {
+  for (const key of ['major', 'minor', 'patch']) {
+    if (a[key] !== b[key]) return Math.sign(a[key] - b[key]);
+  }
+  if (a.prerelease.length === 0 && b.prerelease.length === 0) return 0;
+  if (a.prerelease.length === 0) return 1;
+  if (b.prerelease.length === 0) return -1;
+  for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index += 1) {
+    if (a.prerelease[index] === undefined) return -1;
+    if (b.prerelease[index] === undefined) return 1;
+    const diff = compareIdentifiers(a.prerelease[index], b.prerelease[index]);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+function version(major, minor = 0, patch = 0, prerelease = []) {
+  return { major, minor, patch, prerelease };
+}
+
+function parsePartial(text) {
+  const match = PARTIAL_RE.exec(text);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: match[2] === undefined ? undefined : Number(match[2]),
+    patch: match[3] === undefined ? undefined : Number(match[3]),
+    prerelease: match[4] ? match[4].split('.') : [],
+  };
+}
+
+function floor(partial) {
+  return version(partial.major, partial.minor ?? 0, partial.patch ?? 0, partial.prerelease);
+}
+
+function nextMajor(partial) { return version(partial.major + 1, 0, 0); }
+function nextMinor(partial) { return version(partial.major, (partial.minor ?? 0) + 1, 0); }
+function nextPatch(partial) { return version(partial.major, partial.minor ?? 0, (partial.patch ?? 0) + 1); }
+
+function caretBounds(partial) {
+  const lower = { op: '>=', version: floor(partial) };
+  let upper;
+  if (partial.major > 0) upper = nextMajor(partial);
+  else if ((partial.minor ?? 0) > 0) upper = nextMinor(partial);
+  else upper = nextPatch(partial);
+  return [lower, { op: '<', version: upper }];
+}
+
+function tildeBounds(partial) {
+  const lower = { op: '>=', version: floor(partial) };
+  const upper = partial.minor === undefined ? nextMajor(partial) : nextMinor(partial);
+  return [lower, { op: '<', version: upper }];
+}
+
+function bareBounds(partial) {
+  if (partial.major === undefined) return [];
+  // A full version is exact; a partial one is the usual x-range.
+  if (partial.minor !== undefined && partial.patch !== undefined) {
+    return [{ op: '=', version: floor(partial) }];
+  }
+  const lower = { op: '>=', version: floor(partial) };
+  const upper = partial.minor === undefined ? nextMajor(partial) : nextMinor(partial);
+  return [lower, { op: '<', version: upper }];
+}
+
+function operatorBounds(op, partial) {
+  if (partial.major === undefined) return [];
+  const exact = floor(partial);
+  if (op === '>=') return [{ op: '>=', version: exact }];
+  if (op === '>') {
+    if (partial.patch !== undefined) return [{ op: '>', version: exact }];
+    if (partial.minor !== undefined) return [{ op: '>=', version: nextMinor(partial) }];
+    return [{ op: '>=', version: nextMajor(partial) }];
+  }
+  if (op === '<') return [{ op: '<', version: exact }];
+  if (op === '<=') {
+    if (partial.patch !== undefined) return [{ op: '<=', version: exact }];
+    if (partial.minor !== undefined) return [{ op: '<', version: nextMinor(partial) }];
+    return [{ op: '<', version: nextMajor(partial) }];
+  }
+  if (op === '=') return bareBounds(partial);
+  return null;
+}
+
+function parseComparator(token) {
+  if (token === '*' || token === 'x' || token === 'X') return [];
+  const match = /^(>=|<=|>|<|=|\^|~)?\s*(.+)$/.exec(token);
+  if (!match) return null;
+  const op = match[1] ?? '';
+  const text = match[2];
+  const partial = parsePartial(text);
+  if (!partial) return null;
+  if (op === '^') return caretBounds(partial);
+  if (op === '~') return tildeBounds(partial);
+  if (op === '') return bareBounds(partial);
+  return operatorBounds(op, partial);
+}
+
+function parseHyphen(left, right) {
+  const a = parsePartial(left);
+  const b = parsePartial(right);
+  if (!a || !b || a.major === undefined || b.major === undefined) return null;
+  const bounds = [{ op: '>=', version: floor(a) }];
+  if (b.patch !== undefined) bounds.push({ op: '<=', version: floor(b) });
+  else if (b.minor !== undefined) bounds.push({ op: '<', version: nextMinor(b) });
+  else bounds.push({ op: '<', version: nextMajor(b) });
+  return bounds;
+}
+
+function parseAlternative(text) {
+  const trimmed = text.trim();
+  if (trimmed === '') return null;
+  const hyphen = /^(\S+)\s+-\s+(\S+)$/.exec(trimmed);
+  if (hyphen) return parseHyphen(hyphen[1], hyphen[2]);
+  const tokens = trimmed.split(/\s+/);
+  const bounds = [];
+  for (const token of tokens) {
+    const parsed = parseComparator(token);
+    if (parsed === null) return null;
+    bounds.push(...parsed);
+  }
+  return bounds;
+}
+
+/** true / false / null (null = outside the supported grammar). */
+export function evaluateRange(text) {
+  const raw = String(text ?? '').trim();
+  if (raw === '' || /^workspace:/.test(raw)) return null;
+  const alternatives = raw.split('||').map(parseAlternative);
+  if (alternatives.some((alt) => alt === null)) return null;
+  return alternatives;
+}
+
+export function satisfies(versionText, rangeText) {
+  const target = parseVersion(versionText);
+  if (!target) return null;
+  const alternatives = evaluateRange(rangeText);
+  if (alternatives === null) return null;
+  for (const bounds of alternatives) {
+    let ok = true;
+    for (const bound of bounds) {
+      const cmp = compareVersions(target, bound.version);
+      const pass = bound.op === '>' ? cmp > 0
+        : bound.op === '>=' ? cmp >= 0
+          : bound.op === '<' ? cmp < 0
+            : bound.op === '<=' ? cmp <= 0
+              : cmp === 0;
+      if (!pass) { ok = false; break; }
+    }
+    if (ok) return true;
+  }
+  return false;
+}
+
+/** Whether a range uses only the supported grammar. */
+export function isDecidableRange(text) {
+  return evaluateRange(text) !== null;
+}

package/src/core/tarball.js

@@ -0,0 +1,90 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, normalize } from 'node:path';
+import { gunzipSync } from 'node:zlib';
+
+const BLOCK = 512;
+const MAX_ENTRIES = 10000;
+const MAX_BYTES = 256 * 1024 * 1024;
+
+function text(buffer, start, length) {
+  return buffer.subarray(start, start + length).toString('utf8').replace(/\0.*$/, '').trim();
+}
+
+function safeRelative(name) {
+  const normalized = String(name).replace(/\\/g, '/').replace(/^\/+/, '');
+  if (!normalized || normalized.split('/').includes('..')) {
+    throw new Error('tarball entry escapes the extraction directory: ' + name);
+  }
+  return normalize(normalized);
+}
+
+function parsePax(body) {
+  const records = {};
+  let offset = 0;
+  while (offset < body.length) {
+    const space = body.indexOf(0x20, offset);
+    if (space < 0) break;
+    const length = Number(body.subarray(offset, space).toString('ascii'));
+    if (!Number.isFinite(length) || length <= 0) break;
+    const record = body.subarray(space + 1, offset + length - 1).toString('utf8');
+    const equals = record.indexOf('=');
+    if (equals > 0) records[record.slice(0, equals)] = record.slice(equals + 1);
+    offset += length;
+  }
+  return records;
+}
+
+/**
+ * Extract an npm tarball without dependencies. Only regular files and
+ * directories are written; symlinks, hardlinks, and path traversal are
+ * rejected. Returns the extracted file list.
+ */
+export function extractTarball(buffer, dest) {
+  const tar = gunzipSync(buffer);
+  let offset = 0;
+  let entries = 0;
+  let bytes = 0;
+  let pax = {};
+  let longName;
+  const files = [];
+  while (offset + BLOCK <= tar.length) {
+    const header = tar.subarray(offset, offset + BLOCK);
+    if (header.every((byte) => byte === 0)) break;
+    const name = text(header, 0, 100);
+    const size = parseInt(text(header, 124, 12) || '0', 8);
+    const type = String.fromCharCode(header[156] || 48);
+    const prefix = text(header, 345, 155);
+    const dataStart = offset + BLOCK;
+    const dataEnd = dataStart + size;
+    if (dataEnd > tar.length) throw new Error('tarball entry extends past the archive: ' + name);
+    const body = tar.subarray(dataStart, dataEnd);
+    offset = dataStart + Math.ceil(size / BLOCK) * BLOCK;
+    entries += 1;
+    if (entries > MAX_ENTRIES) throw new Error('tarball has too many entries');
+    bytes += size;
+    if (bytes > MAX_BYTES) throw new Error('tarball expands beyond the size limit');
+
+    if (type === 'x' || type === 'g') { pax = { ...pax, ...parsePax(body) }; continue; }
+    if (type === 'L') { longName = text(body, 0, body.length); continue; }
+
+    const rawPath = longName || pax.path || (prefix ? prefix + '/' + name : name);
+    longName = undefined;
+    pax = {};
+
+    if (type === '5') {
+      mkdirSync(join(dest, safeRelative(rawPath)), { recursive: true });
+      continue;
+    }
+    if (type === '0' || type === '\0' || type === '7') {
+      const path = join(dest, safeRelative(rawPath));
+      mkdirSync(dirname(path), { recursive: true });
+      writeFileSync(path, body);
+      files.push(safeRelative(rawPath));
+      continue;
+    }
+    if (type === '1' || type === '2') {
+      throw new Error('tarball contains a link: ' + rawPath);
+    }
+  }
+  return files;
+}

package/src/data/event-types.json

@@ -1,11 +1,13 @@
 {
   "$comment": "Session event types observed in the official DeepSeek Harness packages. Regenerate with scripts/harvest-event-types.mjs against an installed DSH.",
   "source": "DeepSeek Harness (MIT); harvested from @deepseek-ai/* lib bundles",
-  "harvestedAt": "2026-10-13",
-  "filesScanned": 470,
-  "appendSiteTypes": 45,
-  "observedTypes": 280,
+  "harvestedAt": "2026-11-06",
+  "filesScanned": 472,
+  "appendSiteTypes": 46,
+  "observedTypes": 379,
   "types": [
+    "a/b",
+    "account/watch",
     "agent-loop/config-start-failed",
     "agent-preset/conflict",
     "agent-preset/invalid",
@@ -33,13 +35,28 @@
     "approval/request",
     "assistant/attempt",
     "assistant/chunk",
+    "assistant/live",
     "assistant/live-chunk",
     "assistant/message",
     "authorization/settled",
+    "client-console/disable",
+    "client-console/enable",
+    "client-console/event",
+    "client-runtime/cancel",
+    "client-runtime/get-properties",
+    "client-runtime/request",
+    "client-runtime/response",
+    "client-runtime/response-acknowledged",
+    "client-runtime/session-closed",
+    "client-sources/request",
+    "client-sources/response",
+    "client-sources/session-closed",
     "command/done",
     "command/executed",
     "command/run",
     "commands/change",
+    "commands/execute",
+    "commands/list",
     "compact/end",
     "compact/prune",
     "compact/start",
@@ -51,17 +68,20 @@
     "compaction/summary-error",
     "connection/request",
     "connection/reset",
+    "cordis-tree/get",
     "cordis/dynamic-package",
     "cordis/dynamic-retract",
     "cordis/inspect-query",
     "cordis/inspect-query-resolved",
     "cordis/request-run",
     "cordis/request-run-resolved",
+    "cordis/tree",
     "credential/rejected",
     "credentials/describe",
     "credentials/record-updated",
     "credentials/reference-updated",
     "credentials/set",
+    "credentials/unset",
     "deepseek-account/model-sign-in-required",
     "deepseek-account/session-expired",
     "deepseek-account/signed-out",
@@ -74,6 +94,7 @@
     "document-render/failed",
     "domain/changed",
     "dsh-commands/brand",
+    "dsh-experimental-inspector/0",
     "dsh-llm/brand",
     "ecdsa/rsa",
     "eventsource-parser/stream",
@@ -83,6 +104,13 @@
     "feedback/message-delete",
     "feedback/message-put",
     "feedback/record",
+    "fetch/end",
+    "fetch/error",
+    "fetch/request-body-chunk",
+    "fetch/request-body-end",
+    "fetch/response",
+    "fetch/response-body-chunk",
+    "fetch/start",
     "fmwvqz/sqb",
     "fmwvqz/sqlefppjlmbopmf",
     "foo/bar",
@@ -100,12 +128,14 @@
     "gateway/context-unavailable",
     "gateway/definition-unavailable",
     "gateway/input-invalid",
+    "gateway/interactions-forbidden",
     "gateway/internal",
     "gateway/invocation-unavailable",
     "gateway/lookup-failed",
     "gateway/lookup-not-found",
     "gateway/lookup-unavailable",
     "gateway/method-unavailable",
+    "gateway/peer-disposed",
     "gateway/protocol",
     "gateway/provider-mismatch",
     "gateway/result-invalid",
@@ -115,6 +145,13 @@
     "goal/activation-changed",
     "goal/change",
     "goal/changed",
+    "goals/clear",
+    "goals/complete",
+    "goals/create",
+    "goals/edit",
+    "goals/get",
+    "goals/pause",
+    "goals/resume",
     "hmr/change",
     "hmr/reload",
     "hook/invoked",
@@ -129,7 +166,12 @@
     "internal/set",
     "internal/status",
     "internal/update",
+    "job/follow",
+    "job/kill",
+    "job/list",
     "job/not-found",
+    "job/registered",
+    "job/settled",
     "kb/mqfbgj",
     "llm/adapters-updated",
     "llm/model-discovery-rejected",
@@ -151,6 +193,7 @@
     "model/selection",
     "permission-presets/catalog-changed",
     "permission/preset",
+    "picomatch/posix",
     "plan/invalid-address",
     "plan/mode",
     "plan/not-found",
@@ -159,51 +202,96 @@
     "plugin-manager/changed",
     "plugin-manager/install-log",
     "plugin-manager/install-state",
+    "plugin-market/changed",
+    "plugin-market/fetch-failed",
+    "plugin-market/invalid-index",
+    "plugin-market/invalid-index-url",
+    "plugin-market/invalid-query",
+    "plugin-market/settings-unavailable",
+    "plugin-market/unknown-index",
+    "query/request",
+    "query/response",
+    "remote-access/denied",
     "request/context",
     "request/header",
     "request/header-delta",
     "resources/list",
     "resources/read",
     "sandbox/mode",
+    "schedule/catalog",
     "schedule/change",
     "schedule/changed",
+    "schedule/delete",
+    "schedule/history",
     "schedule/list",
+    "schedule/update",
     "session-log-deepseek/delivery-accepted",
     "session-telemetry/record",
     "session/agent-busy",
+    "session/attachment",
     "session/attachment-invalid",
+    "session/cancel",
     "session/conflict",
+    "session/control",
+    "session/create",
     "session/created",
     "session/disposed",
     "session/end-seed",
     "session/event",
     "session/flush",
+    "session/follow",
+    "session/fork",
     "session/fork-unavailable",
     "session/invalid-time-zone",
+    "session/list",
+    "session/migration-required",
     "session/model-unavailable",
     "session/not-found",
+    "session/page",
+    "session/projections",
     "session/projections-unavailable",
     "session/prompt",
     "session/provider-credentials-unavailable",
     "session/provider-models-unavailable",
     "session/queue-item-not-found",
+    "session/rename",
+    "session/resume",
+    "session/search",
     "session/steer-unavailable",
     "session/title",
     "session/title-invalid",
     "session/title-llm-request",
+    "session/wait",
     "session/workspace-attach-failed",
     "session/writer-held",
     "settings/conflict",
+    "settings/describe",
     "settings/document-updated",
+    "settings/mutate",
     "settings/rejected",
-    "shiki/core",
+    "settings/replace",
+    "settings/update",
     "skills/change",
+    "skills/list",
     "slash/input-begin-command",
     "slash/input-consume-token",
     "slash/input-insert-reference",
     "slash/input-insert-text",
     "slots/changed",
+    "source/accepted",
+    "source/append",
+    "source/append-acknowledged",
+    "source/close",
+    "source/open",
+    "source/rejected",
+    "source/replace",
+    "source/resnapshot",
+    "speech/catalog",
+    "speech/configure",
+    "speech/follow",
     "speech/invalid-audio",
+    "speech/prepare",
+    "speech/transcribe",
     "speech/transcription-failed",
     "steering/message",
     "step/end",
@@ -223,13 +311,22 @@
     "subagent/provider-removed",
     "subagent/start",
     "subagent/unauthorized",
+    "subagents/prompt",
     "system-prompt/assemble",
     "system-prompt/change",
     "system/message",
     "team/member",
     "team/task",
+    "terminal/attach",
+    "terminal/close",
     "terminal/control-unavailable",
+    "terminal/create",
+    "terminal/environment",
     "terminal/limit-reached",
+    "terminal/list",
+    "terminal/rename",
+    "terminal/retain",
+    "terminal/shells",
     "terminal/unavailable",
     "terminal/view",
     "theme/change",
@@ -266,6 +363,7 @@
     "workflow/log",
     "workflow/phase",
     "workflow/start",
+    "working-directory/change",
     "workspace-file/not-directory",
     "workspace-file/not-found",
     "workspace-file/not-regular-file",
@@ -276,16 +374,20 @@
     "workspace-file/unsupported-address",
     "workspace-file/watch-unsupported",
     "workspace/changes",
+    "workspace/create",
+    "workspace/delete",
+    "workspace/follow",
     "workspace/invalid-path",
     "workspace/move-invalid",
     "workspace/name-conflict",
     "workspace/not-found",
+    "workspace/rename",
     "workspace/session-active",
     "workspace/session-activity",
     "workspace/session-stop",
-    "x/name",
-    "zustand/middleware",
-    "zustand/shallow",
-    "zustand/vanilla"
+    "x/name"
+  ],
+  "dshVersions": [
+    "0.2.1-rc.5"
   ]
 }