review: hoist logger to file scope, drop logFatalSync

Applying @grypez review feedback on PR #966:

- Move the logger and its path from inside main() to file scope,
  matching the entrypoint convention already used by app.ts,
  background.ts, and vat-worker.ts.
- Delete logFatalSync — the logger's dispatch routine is synchronous
  (Logger.#dispatch iterates transports via .forEach) and the file
  transport itself is appendFileSync, so logger.error(...) from
  inside a fatal handler flushes to disk before the process exits.
- Fatal handlers now call logger.error directly instead of the
  parallel sync helper.

Behaviour is unchanged: every terminating path still writes a
line to daemon.log before the process goes away.

Author: FUDCo

packages/kernel-cli/src/commands/daemon-entry.ts

@@ -11,6 +11,13 @@ import { join } from 'node:path';
 import { getOcapHome } from '../ocap-home.ts';
 import { isProcessAlive } from '../utils.ts';
 
+const ocapDir = getOcapHome();
+const logPath = join(ocapDir, 'daemon.log');
+const logger = new Logger({
+  tags: ['daemon'],
+  transports: [makeFileTransport(logPath)],
+});
+
 // Install exit-cause handlers at module load, before main() runs, so
 // failures during kernel init also leave a fingerprint. daemon-entry
 // runs with `stdio: 'ignore'` under the CLI spawner (see
@@ -20,7 +27,7 @@ import { isProcessAlive } from '../utils.ts';
 // time — see the run-notes for two past cases where a daemon
 // disappeared with no trace. Every terminating path now writes at
 // least one line before the process goes away.
-installFatalHandlers(join(getOcapHome(), 'daemon.log'));
+installFatalHandlers();
 
 main().catch((error) => {
   process.stderr.write(`Daemon fatal: ${String(error)}\n`);
@@ -31,15 +38,8 @@ main().catch((error) => {
  * Main daemon entry point. Starts the daemon process and keeps it running.
  */
 async function main(): Promise<void> {
-  const ocapDir = getOcapHome();
   await mkdir(ocapDir, { recursive: true });
 
-  const logPath = join(ocapDir, 'daemon.log');
-  const logger = new Logger({
-    tags: ['daemon'],
-    transports: [makeFileTransport(logPath)],
-  });
-
   const socketPath =
     process.env.OCAP_SOCKET_PATH ?? join(ocapDir, 'daemon.sock');
 
@@ -141,49 +141,27 @@ async function readDaemonPid(pidPath: string): Promise<number | undefined> {
 /**
  * Create a file transport that writes logs to a file.
  *
- * @param logPath - The log file path.
+ * @param logFilePath - The log file path.
  * @returns A log transport function.
  */
-function makeFileTransport(logPath: string) {
+function makeFileTransport(logFilePath: string) {
   return (entry: LogEntry): void => {
     const line = `[${new Date().toISOString()}] [${entry.level}] ${entry.message ?? ''} ${(entry.data ?? []).map(String).join(' ')}\n`;
     // eslint-disable-next-line n/no-sync -- synchronous write needed for log transport reliability
-    appendFileSync(logPath, line);
+    appendFileSync(logFilePath, line);
   };
 }
 
-/**
- * Append a fatal-path entry to `daemon.log` synchronously. Used from
- * `process.on('uncaughtException' | 'unhandledRejection' | 'SIGHUP')`
- * handlers where the async logger pipeline can't be trusted to
- * flush before the process exits. Best-effort: if the log file is
- * unwritable we swallow the error rather than throw from a fatal
- * handler.
- *
- * @param logPath - The daemon-log file path.
- * @param message - Short label for the entry.
- * @param detail - Optional extra data (stack, error, etc.) — coerced
- *   to string.
- */
-function logFatalSync(
-  logPath: string,
-  message: string,
-  detail?: string | number,
-): void {
-  try {
-    const tail = detail === undefined ? '' : ` ${detail}`;
-    const line = `[${new Date().toISOString()}] [error] ${message}${tail}\n`;
-    // eslint-disable-next-line n/no-sync -- fatal handler must flush before exit
-    appendFileSync(logPath, line);
-  } catch {
-    // Best-effort — the daemon is dying either way.
-  }
-}
-
 /**
  * Install process-level handlers that guarantee a log line is
  * written for every terminating event before the daemon exits.
  *
+ * The `@metamask/logger` dispatch routine is synchronous and the
+ * file transport we're using here is `appendFileSync` under the
+ * hood, so `logger.error(...)` from inside a fatal handler flushes
+ * to disk before the process exits — no separate sync-write path
+ * is required.
+ *
  * Handlers registered:
  *
  * - `uncaughtException` — the classic silent-death path. Node's
@@ -199,33 +177,30 @@ function logFatalSync(
  *   process; installing a handler lets us log the fact before
  *   exiting.
  * - `exit` — last-ditch record. Fires during every exit, including
- *   the ones already logged by the handlers above. Sync-safe: only
- *   sync APIs are usable here.
- *
- * @param logPath - The daemon-log file path.
+ *   the ones already logged by the handlers above.
  */
-function installFatalHandlers(logPath: string): void {
-  /* eslint-disable n/no-sync, n/no-process-exit -- fatal handlers must flush synchronously and terminate deterministically */
+function installFatalHandlers(): void {
+  /* eslint-disable n/no-process-exit -- fatal handlers must terminate deterministically */
   process.on('uncaughtException', (error: unknown) => {
     const detail =
       error instanceof Error ? (error.stack ?? error.message) : String(error);
-    logFatalSync(logPath, 'Uncaught exception (about to exit):', detail);
+    logger.error('Uncaught exception', detail);
     process.exit(1);
   });
   process.on('unhandledRejection', (reason: unknown) => {
     const detail =
       reason instanceof Error
         ? (reason.stack ?? reason.message)
         : String(reason);
-    logFatalSync(logPath, 'Unhandled rejection (about to exit):', detail);
+    logger.error('Unhandled rejection', detail);
     process.exit(1);
   });
   process.on('SIGHUP', () => {
-    logFatalSync(logPath, 'SIGHUP received; exiting.');
+    logger.error('SIGHUP received; exiting.');
     process.exit(0);
   });
   process.on('exit', (code) => {
-    logFatalSync(logPath, `Process exiting (code=${code}).`);
+    logger.error(`Process exiting (code=${code}).`);
   });
-  /* eslint-enable n/no-sync, n/no-process-exit */
+  /* eslint-enable n/no-process-exit */
 }