@ran-sh/dsh-crew 2.0.13 → 2.0.15

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-crew",
-  "version": "2.0.13",
+  "version": "2.0.15",
   "description": "Dispatch subtasks to DeepSeek Harness (DSH) agents as native subagents with live progress",
   "author": {
     "name": "ZSeven-W"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ran-sh/dsh-crew",
-  "version": "2.0.13",
+  "version": "2.0.15",
   "type": "module",
   "main": "./src/hub/entry.mjs",
   "bin": {

package/src/install/install-legacy.mjs

@@ -4,7 +4,7 @@
 
 import { readFileSync, writeFileSync, mkdirSync, copyFileSync, existsSync, readdirSync, rmSync, statSync, lstatSync, opendirSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { createRequire } from 'node:module';
+import { createRequire, isBuiltin } from 'node:module';
 import { spawnSync } from 'node:child_process';
 import { dirname, join, resolve, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -36,6 +36,79 @@ const CLAUDE_SNAPSHOT_POLL_MS = 5_000;
 // record stand in for a missing user-scope snapshot, so a failed install read as
 // a current one.
 const CLAUDE_PLUGIN_SCOPE = 'user';
+// What a module specifier can look like: a relative or absolute path, a package
+// name, or a scoped one. Anything else the scan produces is the source text
+// between two quotes, not a dependency.
+const SPECIFIER_SHAPE = /^(?:(?:\.{1,2}\/|\/|[A-Za-z]:[\\/])[^\s"']*|(?:@[^/\s]+\/[^/\s]+|[A-Za-z][\w.-]*)(?:\/[^\s"']*)?)$/;
+
+// A `/` starts a regular expression, not a division, when the last significant
+// token could not end an expression. Getting this wrong desynchronises the scan:
+// the quotes inside a regex were read as string delimiters, and everything after
+// them — including real imports — was swallowed into a phantom literal.
+const REGEX_MAY_FOLLOW = new Set([
+  '(', ',', '=', ':', '[', '!', '&', '|', '?', '{', '}', ';', '=>',
+  'return', 'typeof', 'case', 'in', 'of', 'new', 'delete', 'void', 'instanceof', 'do', 'else', 'yield', 'await',
+]);
+
+/**
+ * Split module source into tokens: comments dropped, string and template literals
+ * kept whole, regular-expression literals kept whole, identifiers single, and
+ * everything else one character. Specifiers are then read from tokens rather than
+ * from the raw text, so a keyword inside a comment or a string is not a
+ * declaration and a quote inside a regex is not a string.
+ */
+export function tokenizeModuleSource(source) {
+  const tokens = [];
+  const text = String(source ?? '');
+  let i = 0;
+  let previous = null;
+  const push = (token) => { tokens.push(token); previous = token; };
+  const scanQuoted = (quote) => {
+    let j = i + 1;
+    while (j < text.length) {
+      if (text[j] === '\\') { j += 2; continue; }
+      if (text[j] === quote) { j += 1; break; }
+      if (quote !== '`' && text[j] === '\n') break;
+      j += 1;
+    }
+    push(text.slice(i, j));
+    i = j;
+  };
+  const scanRegex = () => {
+    let j = i + 1;
+    let inClass = false;
+    while (j < text.length) {
+      const c = text[j];
+      if (c === '\\') { j += 2; continue; }
+      if (c === '\n') break;
+      if (inClass) { if (c === ']') inClass = false; }
+      else if (c === '[') inClass = true;
+      else if (c === '/') { j += 1; break; }
+      j += 1;
+    }
+    while (j < text.length && /[a-z]/i.test(text[j])) j += 1;
+    push(text.slice(i, j));
+    i = j;
+  };
+  while (i < text.length) {
+    const ch = text[i];
+    if (/\s/.test(ch)) { i += 1; continue; }
+    if (ch === '/' && text[i + 1] === '/') { const end = text.indexOf('\n', i); i = end === -1 ? text.length : end; continue; }
+    if (ch === '/' && text[i + 1] === '*') { const end = text.indexOf('*/', i + 2); i = end === -1 ? text.length : end + 2; continue; }
+    if (ch === '"' || ch === "'" || ch === '`') { scanQuoted(ch); continue; }
+    if (ch === '/' && (previous === null || REGEX_MAY_FOLLOW.has(previous))) { scanRegex(); continue; }
+    if (/[A-Za-z_$]/.test(ch)) {
+      let j = i + 1;
+      while (j < text.length && /[\w$]/.test(text[j])) j += 1;
+      push(text.slice(i, j));
+      i = j;
+      continue;
+    }
+    push(ch);
+    i += 1;
+  }
+  return tokens;
+}
 const POLICY_START = '<!-- DSH CREW MANAGED POLICY:START -->';
 const POLICY_END = '<!-- DSH CREW MANAGED POLICY:END -->';
 
@@ -593,25 +666,65 @@ export function claudeSnapshotSettleMs(err) {
  * present is what *it* imports. The manifest is not a substitute: it declares 28
  * dependencies, including meta-packages the server never imports from here, and
  * requiring all of them to resolve read a working install as broken. Resolution
- * is asked from the entry itself, and subpath specifiers are kept as they are —
+ * follows local modules from the entry, and subpath specifiers are kept as they are —
  * `@modelcontextprotocol/sdk/server/mcp.js` resolves through its package's
  * `exports`, which the bare package name does not.
  */
 function claudeSnapshotResolvable(snapshotRoot) {
   if (typeof snapshotRoot !== 'string' || !snapshotRoot.trim()) return false;
-  const entry = join(snapshotRoot, 'src', 'server.mjs');
-  if (!existsSync(entry)) return false;
-  let source;
-  try { source = readFileSync(entry, 'utf8'); } catch { return false; }
-  const specifiers = [...source.matchAll(/(?:from|import)\s*\(?\s*['"]([^'"]+)['"]/g)]
-    .map((match) => match[1])
-    .filter((specifier) => !specifier.startsWith('.') && !specifier.startsWith('node:'));
-  if (!specifiers.length) return true;
-  let fromEntry;
-  try { fromEntry = createRequire(entry); } catch { return false; }
-  return specifiers.every((specifier) => {
-    try { return existsSync(fromEntry.resolve(specifier)); } catch { return false; }
-  });
+  const root = resolve(snapshotRoot);
+  const visited = new Set();
+  let bytes = 0;
+  const inspect = (entry) => {
+    if (visited.has(entry)) return true;
+    if (visited.size >= 512) return false;
+    const local = relative(root, entry);
+    if (local.startsWith('..') || resolve(root, local) !== entry) return false;
+    visited.add(entry);
+    try {
+      const info = lstatSync(entry);
+      if (!info.isFile() || info.isSymbolicLink() || bytes + info.size > 8 * 1024 * 1024) return false;
+      bytes += info.size;
+      if (!/\.[cm]?js$/i.test(entry)) return true;
+      const source = readFileSync(entry, 'utf8');
+      const fromEntry = createRequire(entry);
+      // Consume comments and literals as complete tokens before recognizing declarations.
+      const tokens = tokenizeModuleSource(source);
+      const specifiers = [];
+      const literal = (token) => token && /^['"]/.test(token);
+      for (let i = 0; i < tokens.length; i += 1) {
+        if (!['import', 'export', 'require'].includes(tokens[i])) continue;
+        if (tokens[i - 1] === '.') continue;
+        let next = i + 1;
+        while (tokens[next]?.startsWith('/*') || tokens[next]?.startsWith('//')) next += 1;
+        if (['import', 'require'].includes(tokens[i]) && tokens[next] === '(') {
+          if (literal(tokens[next + 1])) specifiers.push(tokens[next + 1].slice(1, -1));
+          continue;
+        }
+        if (tokens[i] === 'require') continue;
+        if (literal(tokens[next])) { specifiers.push(tokens[next].slice(1, -1)); continue; }
+        // Only import/export declarations can introduce a `from` clause.
+        if (tokens[next] === '.' || tokens[next] === '(' || ['const', 'let', 'var', 'function', 'class', 'default', 'async'].includes(tokens[next])) continue;
+        for (let j = next; j < tokens.length && tokens[j] !== ';'; j += 1) {
+          if (tokens[j] === 'from' && literal(tokens[j + 1])) { specifiers.push(tokens[j + 1].slice(1, -1)); break; }
+        }
+      }
+      // The scan is lexical, and a regex literal holding a quote — `/^['"]/`, or
+      // the TOML matchers above — desynchronises it: the phantom string swallows
+      // text up to the next quote in the file, which can expose a keyword as a
+      // bare token and hand back the source between two of them as a "specifier".
+      // Those are not module specifiers, and resolving them read a working install
+      // as broken, so anything not shaped like a path or a package name is dropped.
+      const shaped = specifiers.filter((specifier) => isBuiltin(specifier) || SPECIFIER_SHAPE.test(specifier));
+      return shaped.every((specifier) => {
+        if (isBuiltin(specifier)) return true;
+        const target = fromEntry.resolve(specifier);
+        if (!existsSync(target)) return false;
+        return specifier.startsWith('.') ? inspect(target) : true;
+      });
+    } catch { return false; }
+  };
+  return inspect(join(root, 'src', 'server.mjs'));
 }
 
 /**

package/src/install/npx-lifecycle.mjs

@@ -1181,9 +1181,15 @@ export function defaultPayloadSmoke(dir, { nodePath = process.execPath, runner =
 // Keyword boundaries reject identifiers containing the keywords
 // ('legacy-import') and member calls (.from); captures stay on one line and
 // bounded — real specifiers never span lines.
-const IMPORT_SPECIFIER_RE = /(?<![\w.\-])(?:from|import|require)\b\s*\(?\s*["']([^"'\n]{1,200})["']/g;
-
-function collectExternalSpecifiers(dir) {
+//
+// A quote before the keyword is rejected too. Writing the keyword as a string —
+// `['import', 'export', 'require'].includes(word)` — is ordinary JavaScript, and
+// without this the closing quote of `'import'` was taken for the opening quote of
+// a specifier: it captured the text between two keywords and the payload failed to
+// stage on code that imports nothing at all.
+const IMPORT_SPECIFIER_RE = /(?<![\w.\-'"`])(?:from|import|require)\b\s*\(?\s*["']([^"'\n]{1,200})["']/g;
+
+export function collectExternalSpecifiers(dir) {
   const specifiers = new Set();
   const walk = (root) => {
     if (!existsSync(root)) return;

package/src/runtime-identity.mjs

@@ -36,7 +36,7 @@ export {
 // included in the identity contract.
 const RUNTIME_ID = randomUUID();
 
-export const RUNTIME_VERSION = '2.0.13';
+export const RUNTIME_VERSION = '2.0.15';
 export const HUB_PROTOCOL_VERSION = 1;
 
 export const HUB_CAPABILITIES = Object.freeze([