fix: restart stale daemon after source changes

Author: thymikee

src/daemon-client.ts

@@ -13,6 +13,7 @@ import { runCmdDetached, runCmdSync } from './utils/exec.ts';
 import { findProjectRoot, readVersion } from './utils/version.ts';
 import { createRequestId, emitDiagnostic, withDiagnosticTimer } from './utils/diagnostics.ts';
 import { isAgentDeviceDaemonProcess, stopProcessForTakeover } from './utils/process-identity.ts';
+import { computeDaemonCodeSignature as computeSharedDaemonCodeSignature } from './daemon/code-signature.ts';
 import {
   resolveDaemonPaths,
   resolveDaemonServerMode,
@@ -738,13 +739,7 @@ export function computeDaemonCodeSignature(
   entryPath: string,
   root: string = findProjectRoot(),
 ): string {
-  try {
-    const stat = fs.statSync(entryPath);
-    const relativePath = path.relative(root, entryPath) || entryPath;
-    return `${relativePath}:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
-  } catch {
-    return 'unknown';
-  }
+  return computeSharedDaemonCodeSignature(entryPath, root);
 }
 
 async function sendRequest(

src/daemon/code-signature.ts

@@ -0,0 +1,75 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { findProjectRoot } from '../utils/version.ts';
+
+export function resolveDaemonCodeSignature(
+  entryPath: string | undefined = process.argv[1],
+  root: string = findProjectRoot(),
+): string {
+  if (!entryPath) return 'unknown';
+  return computeDaemonCodeSignature(entryPath, root);
+}
+
+export function computeDaemonCodeSignature(
+  entryPath: string,
+  root: string = findProjectRoot(),
+): string {
+  const targetPath = resolveDaemonCodeSignatureTarget(entryPath, root);
+  try {
+    const stat = fs.statSync(targetPath);
+    if (!stat.isDirectory()) {
+      return formatSingleFileSignature(targetPath, stat, root);
+    }
+
+    const hash = crypto.createHash('sha256');
+    let fileCount = 0;
+    for (const filePath of walkSignatureFiles(targetPath)) {
+      const fileStat = fs.statSync(filePath);
+      const relativePath = path.relative(root, filePath) || path.basename(filePath);
+      hash.update(
+        `${relativePath}:${fileStat.size}:${Math.trunc(fileStat.mtimeMs)}:${fileStat.mode}\n`,
+      );
+      fileCount += 1;
+    }
+
+    const relativeTarget = path.relative(root, targetPath) || path.basename(targetPath);
+    return `${relativeTarget}:${fileCount}:${hash.digest('hex').slice(0, 16)}`;
+  } catch {
+    return 'unknown';
+  }
+}
+
+function resolveDaemonCodeSignatureTarget(entryPath: string, root: string): string {
+  const resolvedEntryPath = path.resolve(entryPath);
+  const sourceDaemonEntry = path.join(root, 'src', 'daemon.ts');
+  const distDaemonEntry = path.join(root, 'dist', 'src', 'daemon.js');
+  if (resolvedEntryPath === sourceDaemonEntry) {
+    return path.join(root, 'src');
+  }
+  if (resolvedEntryPath === distDaemonEntry) {
+    return path.join(root, 'dist', 'src');
+  }
+  return resolvedEntryPath;
+}
+
+function formatSingleFileSignature(filePath: string, stat: fs.Stats, root: string): string {
+  const relativePath = path.relative(root, filePath) || path.basename(filePath);
+  return `${relativePath}:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+}
+
+function* walkSignatureFiles(dirPath: string): Generator<string> {
+  const entries = fs
+    .readdirSync(dirPath, { withFileTypes: true })
+    .sort((left, right) => left.name.localeCompare(right.name));
+  for (const entry of entries) {
+    const entryPath = path.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      yield* walkSignatureFiles(entryPath);
+      continue;
+    }
+    if (entry.isFile()) {
+      yield entryPath;
+    }
+  }
+}

src/daemon/server-lifecycle.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
-import path from 'node:path';
-import { findProjectRoot, readVersion } from '../utils/version.ts';
+import { readVersion } from '../utils/version.ts';
 import { isAgentDeviceDaemonProcess, readProcessStartTime } from '../utils/process-identity.ts';
+import { resolveDaemonCodeSignature as resolveSharedDaemonCodeSignature } from './code-signature.ts';
 
 export type DaemonLockInfo = {
   pid: number;
@@ -11,16 +11,7 @@ export type DaemonLockInfo = {
 };
 
 export function resolveDaemonCodeSignature(): string {
-  const entryPath = process.argv[1];
-  if (!entryPath) return 'unknown';
-  try {
-    const stat = fs.statSync(entryPath);
-    const root = findProjectRoot();
-    const relativePath = path.relative(root, entryPath) || entryPath;
-    return `${relativePath}:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
-  } catch {
-    return 'unknown';
-  }
+  return resolveSharedDaemonCodeSignature(process.argv[1]);
 }
 
 export function writeInfo(

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

@@ -1032,14 +1032,21 @@ test('downloadRemoteArtifact times out stalled artifact responses and removes pa
   }
 });
 
-test('computeDaemonCodeSignature includes relative path, size, and mtime', () => {
+test('computeDaemonCodeSignature fingerprints the daemon source tree', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-daemon-signature-'));
   try {
-    const daemonEntryPath = path.join(root, 'dist', 'src', 'daemon.js');
-    fs.mkdirSync(path.dirname(daemonEntryPath), { recursive: true });
+    const daemonEntryPath = path.join(root, 'src', 'daemon.ts');
+    const perfPath = path.join(root, 'src', 'platforms', 'ios', 'perf.ts');
+    fs.mkdirSync(path.dirname(perfPath), { recursive: true });
     fs.writeFileSync(daemonEntryPath, 'console.log("daemon");\n', 'utf8');
-    const signature = computeDaemonCodeSignature(daemonEntryPath, root);
-    assert.match(signature, /^dist\/src\/daemon\.js:\d+:\d+$/);
+    fs.writeFileSync(perfPath, 'export const value = 1;\n', 'utf8');
+
+    const firstSignature = computeDaemonCodeSignature(daemonEntryPath, root);
+    assert.match(firstSignature, /^src:\d+:[a-f0-9]{16}$/);
+
+    fs.writeFileSync(perfPath, 'export const value = 2;\n', 'utf8');
+    const secondSignature = computeDaemonCodeSignature(daemonEntryPath, root);
+    assert.notEqual(secondSignature, firstSignature);
   } finally {
     fs.rmSync(root, { recursive: true, force: true });
   }