refactor(logger): add tagless console and file transports

Add `ConsoleTransport` and `FileTransport` classes with a tagless
architecture for flexible log routing. Console transport wraps
`globalThis.console`, file transport appends to a file via
`node:fs`. Both are exported from `@metamask/logger/transports`.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: grypez

packages/logger/package.json

@@ -29,6 +29,16 @@
         "default": "./dist/index.cjs"
       }
     },
+    "./file-transport": {
+      "import": {
+        "types": "./dist/file-transport.d.mts",
+        "default": "./dist/file-transport.mjs"
+      },
+      "require": {
+        "types": "./dist/file-transport.d.cts",
+        "default": "./dist/file-transport.cjs"
+      }
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.cjs",

packages/logger/src/file-transport.test.ts

@@ -0,0 +1,76 @@
+import { readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { makeFileTransport } from './file-transport.ts';
+import type { LogEntry } from './types.ts';
+
+const makeLogEntry = (overrides?: Partial<LogEntry>): LogEntry => ({
+  level: 'info',
+  message: 'test-message',
+  tags: ['test-tag'],
+  ...overrides,
+});
+
+describe('makeFileTransport', () => {
+  const testDir = join(tmpdir(), 'logger-file-transport-test');
+
+  afterEach(async () => {
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  it('appends a formatted log line to the file', async () => {
+    const filePath = join(testDir, 'test.log');
+    const transport = makeFileTransport(filePath);
+    const entry = makeLogEntry();
+
+    transport(entry);
+    // Wait for the async write to complete
+    await vi.waitFor(async () => {
+      const content = await readFile(filePath, 'utf-8');
+      expect(content).toContain('[info] [test-tag] test-message');
+    });
+  });
+
+  it('creates parent directories', async () => {
+    const filePath = join(testDir, 'nested', 'deep', 'test.log');
+    const transport = makeFileTransport(filePath);
+
+    transport(makeLogEntry());
+    await vi.waitFor(async () => {
+      const content = await readFile(filePath, 'utf-8');
+      expect(content).toContain('test-message');
+    });
+  });
+
+  it('omits tag prefix when tags are empty', async () => {
+    const filePath = join(testDir, 'no-tags.log');
+    const transport = makeFileTransport(filePath);
+
+    transport(makeLogEntry({ tags: [] }));
+    await vi.waitFor(async () => {
+      const content = await readFile(filePath, 'utf-8');
+      expect(content).toMatch(/\[info\] test-message/u);
+      expect(content).not.toContain('[]');
+    });
+  });
+
+  it('includes data in the log line', async () => {
+    const filePath = join(testDir, 'data.log');
+    const transport = makeFileTransport(filePath);
+
+    transport(makeLogEntry({ data: ['extra-data'] }));
+    await vi.waitFor(async () => {
+      const content = await readFile(filePath, 'utf-8');
+      expect(content).toContain('test-message extra-data');
+    });
+  });
+
+  it('silently handles write errors', async () => {
+    // Use an invalid path to trigger an error
+    const transport = makeFileTransport('/dev/null/impossible/test.log');
+    // Should not throw
+    expect(() => transport(makeLogEntry())).not.toThrow();
+  });
+});

packages/logger/src/file-transport.ts

@@ -0,0 +1,28 @@
+import { appendFile, mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+import type { Transport } from './types.ts';
+
+/**
+ * Creates a file transport that appends timestamped log lines to a file.
+ * Parent directories are created automatically. Tags are included in the
+ * file output for structured log analysis.
+ *
+ * This transport requires Node.js (`node:fs/promises`).
+ *
+ * @param filePath - Absolute path to the log file.
+ * @returns A transport function that appends to the file.
+ */
+export function makeFileTransport(filePath: string): Transport {
+  return (entry) => {
+    const tags = entry.tags.length > 0 ? `[${entry.tags.join(', ')}] ` : '';
+    const parts = [
+      ...(entry.message ? [entry.message] : []),
+      ...(entry.data ?? []),
+    ];
+    const line = `${new Date().toISOString()} [${entry.level}] ${tags}${parts.join(' ')}\n`;
+    mkdir(dirname(filePath), { recursive: true })
+      .then(async () => appendFile(filePath, line))
+      .catch(() => undefined);
+  };
+}

packages/logger/src/index.ts

@@ -1,6 +1,7 @@
 export { Logger } from './logger.ts';
 export {
   makeConsoleTransport,
+  makeTaglessConsoleTransport,
   makeArrayTransport,
   makeStreamTransport,
 } from './transports.ts';

packages/logger/src/transports.test.ts

@@ -5,6 +5,7 @@ import { describe, expect, it, vi } from 'vitest';
 import { logLevels } from './constants.ts';
 import {
   makeConsoleTransport,
+  makeTaglessConsoleTransport,
   makeArrayTransport,
   makeStreamTransport,
 } from './transports.ts';
@@ -33,6 +34,33 @@ describe('consoleTransport', () => {
   );
 });
 
+describe('taglessConsoleTransport', () => {
+  it.each(Object.keys(logLevels))(
+    'logs without tags for level: %s',
+    (levelString: string) => {
+      const transport = makeTaglessConsoleTransport();
+      const level = levelString as LogLevel;
+      const logEntry = makeLogEntry(level);
+      const consoleMethodSpy = vi.spyOn(console, level);
+      transport(logEntry);
+      expect(consoleMethodSpy).toHaveBeenCalledWith(logEntry.message);
+    },
+  );
+
+  it('omits tags from output', () => {
+    const transport = makeTaglessConsoleTransport();
+    const entry: LogEntry = {
+      level: 'info',
+      message: 'hello',
+      tags: ['cli', 'daemon'],
+      data: ['extra'],
+    };
+    const spy = vi.spyOn(console, 'info');
+    transport(entry);
+    expect(spy).toHaveBeenCalledWith('hello', 'extra');
+  });
+});
+
 describe('makeStreamTransport', () => {
   it('writes to the stream', () => {
     const logLevel = 'info';

packages/logger/src/transports.ts

@@ -42,6 +42,43 @@ export function makeConsoleTransport(level: LogLevel = 'debug'): Transport {
   return consoleTransport;
 }
 
+/**
+ * A console transport that omits tags from output. Useful for CLI tools
+ * where the tag prefix (e.g. `['cli']`) is noise in terminal output.
+ *
+ * @param level - The logging level for this instance.
+ * @returns A transport function that writes to the console without tags.
+ */
+export function makeTaglessConsoleTransport(
+  level: LogLevel = 'debug',
+): Transport {
+  const baseLevelIdx = logLevels[level];
+  const logFn = (method: LogLevel): LogMethod => {
+    if (baseLevelIdx <= logLevels[method]) {
+      return (...args: unknown[]) => {
+        // eslint-disable-next-line no-console
+        console[method](...args);
+      };
+    }
+    // eslint-disable-next-line no-empty-function
+    return harden(() => {}) as LogMethod;
+  };
+  const filteredConsole = {
+    debug: logFn('debug'),
+    info: logFn('info'),
+    log: logFn('log'),
+    warn: logFn('warn'),
+    error: logFn('error'),
+  };
+  return (entry) => {
+    const args = [
+      ...(entry.message ? [entry.message] : []),
+      ...(entry.data ?? []),
+    ] as LogArgs;
+    filteredConsole[entry.level](...args);
+  };
+}
+
 /**
  * The stream transport for the logger. Expects the stream is listening for
  * log entries.

tsconfig.packages.json

@@ -15,6 +15,7 @@
       "@metamask/kernel-store/sqlite/wasm": [
         "../kernel-store/src/sqlite/wasm.ts"
       ],
+      "@metamask/logger/file-transport": ["../logger/src/file-transport.ts"],
       "@ocap/*": ["../*/src"]
     }
   }