@shidesheng0218/dsh-plugin-lint 0.0.0-stage → 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

@@ -0,0 +1,393 @@
+{
+  "$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-11-06",
+  "filesScanned": 472,
+  "appendSiteTypes": 46,
+  "observedTypes": 379,
+  "types": [
+    "a/b",
+    "account/watch",
+    "agent-loop/config-start-failed",
+    "agent-preset/conflict",
+    "agent-preset/invalid",
+    "agent-preset/locked",
+    "agent-preset/not-found",
+    "agent-preset/selected",
+    "agent/assistant-stream",
+    "agent/created",
+    "agent/disposed",
+    "agent/error",
+    "agent/pre-step",
+    "agent/request",
+    "agent/request-error",
+    "agent/status",
+    "agent/turn-stopping",
+    "api-session/activity",
+    "api-session/added",
+    "api-session/error",
+    "api-session/removed",
+    "api-session/status",
+    "app-boot/config-reload",
+    "approval/asked",
+    "approval/decided",
+    "approval/policy",
+    "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",
+    "compact/summary",
+    "compaction/end",
+    "compaction/prune",
+    "compaction/start",
+    "compaction/summary",
+    "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",
+    "deliverables/presented",
+    "developer/message",
+    "directory-picker/create-failed",
+    "directory-picker/exists",
+    "directory-picker/unavailable",
+    "directory-picker/unreadable",
+    "document-render/failed",
+    "domain/changed",
+    "dsh-commands/brand",
+    "dsh-experimental-inspector/0",
+    "dsh-llm/brand",
+    "ecdsa/rsa",
+    "eventsource-parser/stream",
+    "f/aqlbg",
+    "f/gfp",
+    "feedback/committed",
+    "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",
+    "fs/edit-intent",
+    "fs/observed",
+    "fs/promises",
+    "fs/write-intent",
+    "gateway/ambiguous-endpoint",
+    "gateway/arguments-invalid",
+    "gateway/bad-request",
+    "gateway/binding-invalid",
+    "gateway/cancelled",
+    "gateway/context-failed",
+    "gateway/context-not-found",
+    "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",
+    "gateway/service-unavailable",
+    "gateway/signature-invalid",
+    "gateway/uplink-overflow",
+    "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",
+    "hook/result",
+    "image/offload",
+    "internal/config",
+    "internal/dispatch",
+    "internal/get",
+    "internal/listener",
+    "internal/plugin",
+    "internal/service",
+    "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",
+    "llm/retry",
+    "llm/retry-started",
+    "llm/stream",
+    "loader/config-update",
+    "loader/entry-init",
+    "loader/partial-dispose",
+    "loader/patch-context",
+    "loader/volatile-update",
+    "locale/change",
+    "m/h",
+    "m/hr",
+    "m/s",
+    "m/sec",
+    "mm/dd",
+    "mode/set",
+    "model/selection",
+    "permission-presets/catalog-changed",
+    "permission/preset",
+    "picomatch/posix",
+    "plan/invalid-address",
+    "plan/mode",
+    "plan/not-found",
+    "plan/read-failed",
+    "plan/unavailable",
+    "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",
+    "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",
+    "step/start",
+    "subagent/attachment-invalid",
+    "subagent/catalog",
+    "subagent/catalog-diagnostic",
+    "subagent/delivery-unavailable",
+    "subagent/descriptor",
+    "subagent/end",
+    "subagent/invalid-time-zone",
+    "subagent/model-selection-policy",
+    "subagent/not-found",
+    "subagent/not-resumable",
+    "subagent/parent-unavailable",
+    "subagent/provider-added",
+    "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",
+    "todo/write",
+    "tool-workflow/agent-end",
+    "tool-workflow/agent-start",
+    "tool-workflow/run-end",
+    "tool-workflow/run-start",
+    "tool/call",
+    "tool/code-dispatch",
+    "tool/code-dispatch-start",
+    "tool/ptc-dispatch",
+    "tool/ptc-dispatch-start",
+    "tool/result",
+    "tools/call",
+    "tools/change",
+    "tools/execute",
+    "tools/list",
+    "tools/post-execute",
+    "tools/pre-execute",
+    "tools/ptc-dispatch-log",
+    "tools/result",
+    "tsx/esm",
+    "turn/end",
+    "turn/start",
+    "user-questions/request",
+    "user/message",
+    "v3/opaque-released-event",
+    "web/deepseek-search-llm-request",
+    "webserver/index-inject",
+    "workflow/agent-end",
+    "workflow/agent-start",
+    "workflow/end",
+    "workflow/log",
+    "workflow/phase",
+    "workflow/start",
+    "working-directory/change",
+    "workspace-file/not-directory",
+    "workspace-file/not-found",
+    "workspace-file/not-regular-file",
+    "workspace-file/not-text",
+    "workspace-file/outside-workspace",
+    "workspace-file/too-large",
+    "workspace-file/unknown-workspace",
+    "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"
+  ],
+  "dshVersions": [
+    "0.2.1-rc.5"
+  ]
+}