fix: fingerprint the built daemon's real import graph (#1545) (#1771)

* fix: fingerprint the built daemon's real import graph (#1545)

The static-import regex in computeDaemonCodeSignature required whitespace
around `from` and after `import`/`export`. The built daemon entry is a
minified bundle (tsdown/rolldown `minify: true`), whose real import
statements have zero whitespace (e.g. `import{o as e}from"../foo.js"`), so
the regex never matched any dependency edge and the graph walk silently
degraded to fingerprinting only the entry file (`graph:1`) instead of its
true ~50-file runtime graph.

That defeats the safety net the signature exists for: a daemon started from
one build can look identical to a client running a materially different
build as long as the entry file's own size/mtime happen to coincide, and the
"code-signature mismatch" takeover this check drives was one of the
mechanisms observed in #1545's worktree dev-daemon multiplication.

* refactor: fingerprint import specifiers by shape, not by import grammar

Replaces the two keyword-anchored regexes (one for static import/export/from
clauses, one for dynamic import()) with a single pattern that matches any
quoted, relative-path-shaped string literal. The prior approach had to track
the exact whitespace/keyword shape bundlers emit around a specifier, which is
exactly what broke for minified output in the immediately preceding commit —
formatted source, minified builds, static imports, re-exports, and dynamic
imports all put the same thing in the same place (a relative string literal),
so matching on that directly is both simpler and immune to future formatting
differences. A same-shaped string that isn't really an import is safe to
over-match: it just fails to resolve to a file and gets dropped.

Verified the file count is unchanged against this repo's real build (dist:
graph:50, src: graph:741, both identical to the keyword-anchored fix).

Author: thymikee

src/daemon/code-signature.ts

@@ -3,9 +3,18 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { findProjectRoot } from '../utils/version.ts';
 
-const STATIC_IMPORT_RE =
-  /(?:^|[^\w$.])(?:import|export)\s+(?:type\s+)?(?:[^'"`]*?\s+from\s+)?['"]([^'"]+)['"]/gm;
-const DYNAMIC_IMPORT_RE = /import\(\s*['"]([^'"]+)['"]\s*\)/gm;
+// Any quoted, relative-path-shaped string literal is treated as a module
+// specifier, rather than matching the `import`/`export`/`from` grammar
+// around it: bundlers only ever emit relative string literals for real
+// specifiers, but the surrounding syntax varies too much to track reliably —
+// formatted source spaces `import { x } from './y'` out, a minified build
+// (tsdown/rolldown `minify: true`) squashes it to `import{x}from"./y"`, and a
+// keyword-anchored regex tuned for one silently stops matching the other
+// (#1545: the daemon's own built entry fingerprinted to just itself, since
+// nothing downstream of it ever matched). A literal that isn't really an
+// import (e.g. one that shows up inside a comment) simply fails to resolve
+// to a file below and gets dropped, so over-matching here is harmless.
+const RELATIVE_SPECIFIER_RE = /(['"])(\.\.?\/[^'"]*)\1/g;
 const RESOLVABLE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'] as const;
 
 export function resolveDaemonCodeSignature(): string {
@@ -55,20 +64,12 @@ export function computeDaemonCodeSignature(
 
 function collectRelativeImportSpecifiers(content: string): string[] {
   const specifiers = new Set<string>();
-  collectImportMatches(content, STATIC_IMPORT_RE, specifiers);
-  collectImportMatches(content, DYNAMIC_IMPORT_RE, specifiers);
-  return [...specifiers];
-}
-
-function collectImportMatches(content: string, pattern: RegExp, specifiers: Set<string>): void {
-  pattern.lastIndex = 0;
+  RELATIVE_SPECIFIER_RE.lastIndex = 0;
   let match: RegExpExecArray | null = null;
-  while ((match = pattern.exec(content)) !== null) {
-    const specifier = match[1]?.trim();
-    if (specifier?.startsWith('.')) {
-      specifiers.add(specifier);
-    }
+  while ((match = RELATIVE_SPECIFIER_RE.exec(content)) !== null) {
+    specifiers.add(match[2]!);
   }
+  return [...specifiers];
 }
 
 function resolveRelativeImportPath(fromPath: string, specifier: string): string | null {

src/utils/__tests__/daemon-client.test.ts

@@ -1776,6 +1776,74 @@ test('computeDaemonCodeSignature fingerprints the daemon runtime import graph',
   }
 });
 
+test('computeDaemonCodeSignature walks minified bundler output (#1545)', () => {
+  // The published/built daemon entry is a minified bundle (tsdown/rolldown
+  // `minify: true`): real import/export statements have zero whitespace
+  // around `from` or even after the keyword itself, e.g.
+  // `import{o as e}from"./dep.js"`. computeDaemonCodeSignature detects a
+  // dependency edge from the quoted relative-path string alone (not from the
+  // import/export/from grammar around it), so every one of these shapes —
+  // named, re-export-all, and bare side-effect imports — resolves the same
+  // way regardless of formatting, and a same-shaped string that isn't really
+  // an import (the `importantValue` literal below) is simply ignored because
+  // it doesn't resolve to a file.
+  const root = mkdtempForTestSync('agent-device-daemon-signature-minified-');
+  try {
+    const daemonEntryPath = path.join(root, 'daemon.js');
+    const depPath = path.join(root, 'dep.js');
+    const reExportPath = path.join(root, 're-export.js');
+    const sideEffectPath = path.join(root, 'side-effect.js');
+    fs.writeFileSync(
+      daemonEntryPath,
+      [
+        `import{a as x}from"./dep.js";`,
+        `export*from"./re-export.js";`,
+        `import"./side-effect.js";`,
+        `const importantValue="not-an-import";`,
+        `export{x};`,
+      ].join(''),
+      'utf8',
+    );
+    fs.writeFileSync(depPath, `export const a=1;`, 'utf8');
+    fs.writeFileSync(reExportPath, `export const b=1;`, 'utf8');
+    fs.writeFileSync(sideEffectPath, `globalThis.sideEffect=1;`, 'utf8');
+
+    const signature = computeDaemonCodeSignature(daemonEntryPath, root);
+    assert.match(signature, /^graph:4:[0-9a-f]{40}$/);
+
+    // A same-length rewrite can land in the same size+mtime bucket on a fast
+    // filesystem (the fingerprint isn't a content hash); pad the size so this
+    // assertion isn't racing the clock.
+    fs.writeFileSync(depPath, `export const a=200;`, 'utf8');
+    const changed = computeDaemonCodeSignature(daemonEntryPath, root);
+    assert.notEqual(changed, signature);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('computeDaemonCodeSignature ignores a relative-path-shaped string that is not an import', () => {
+  // A quoted `./`-looking string that never resolves to a real file (e.g.
+  // one embedded in a comment or an unrelated string literal) is a candidate
+  // the regex necessarily can't rule out by syntax alone — it must be
+  // dropped by resolution instead. This is what keeps the "match any quoted
+  // relative-path string" strategy safe.
+  const root = mkdtempForTestSync('agent-device-daemon-signature-non-import-');
+  try {
+    const daemonEntryPath = path.join(root, 'daemon.js');
+    fs.writeFileSync(
+      daemonEntryPath,
+      `// example: \`import x from "./does-not-exist.js"\`\nexport const noop=1;`,
+      'utf8',
+    );
+
+    const signature = computeDaemonCodeSignature(daemonEntryPath, root);
+    assert.match(signature, /^graph:1:[0-9a-f]{40}$/);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
 test('stopDaemonProcessForTakeover terminates a matching daemon process', async (t) => {
   const root = mkdtempForTestSync('agent-device-daemon-test-');
   const daemonDir = path.join(root, 'agent-device', 'dist', 'src', 'internal');