fix(debug): buffer pre-init events and flush to real logger on init

packages/desktop/src/main/debug/index.ts

@@ -1,32 +1,106 @@
 import { BrowserWindow } from 'electron';
-import type { DebugEvent } from '@clawwork/shared';
+import type { DebugEvent, LogEventInput } from '@clawwork/shared';
 import type { DebugLogger } from './logger.js';
 import { createDebugLogger } from './logger.js';
 
-const noop = (): DebugEvent => ({ ts: '', level: 'debug', domain: 'app', event: '' }) as DebugEvent;
-let debugLogger: DebugLogger = {
-  debug: noop,
-  info: noop,
-  warn: noop,
-  error: noop,
-  log: noop,
-  getRecentEvents: () => [],
-  currentFilePath: () => '',
-};
+const MAX_PRE_INIT_BUFFER = 256;
+
+let debugLogger: DebugLogger;
+let isInitialized = false;
+
+function createNoopLogger(): DebugLogger {
+  const preInitBuffer: DebugEvent[] = [];
+
+  const flushToLogger = (logger: DebugLogger): void => {
+    for (const event of preInitBuffer) {
+      logger.log({ ...event, level: event.level as LogEventInput['level'] });
+    }
+    preInitBuffer.length = 0;
+  };
+
+  const makeBufferedLog =
+    (level: 'debug' | 'info' | 'warn' | 'error') =>
+    (input: LogEventInput): DebugEvent => {
+      const event: DebugEvent = {
+        ts: new Date().toISOString(),
+        level,
+        domain: input.domain,
+        event: input.event,
+        traceId: input.traceId,
+        feature: input.feature,
+        message: input.message,
+        gatewayId: input.gatewayId,
+        sessionKey: input.sessionKey,
+        taskId: input.taskId,
+        runId: input.runId,
+        requestId: input.requestId,
+        wsFrameId: input.wsFrameId,
+        seq: input.seq,
+        attempt: input.attempt,
+        durationMs: input.durationMs,
+        ok: input.ok,
+        error: input.error,
+        data: input.data,
+      };
+
+      if (preInitBuffer.length < MAX_PRE_INIT_BUFFER) {
+        preInitBuffer.push(event);
+      }
+
+      console.warn(
+        `[debug] Logger not initialized yet (pre-init event captured, buffer size: ${preInitBuffer.length}/${MAX_PRE_INIT_BUFFER}):`,
+        `[${level}] [${input.domain}] ${input.event}`,
+        input,
+      );
+      return event;
+    };
+
+  const noopLogger: DebugLogger = {
+    debug: makeBufferedLog('debug'),
+    info: makeBufferedLog('info'),
+    warn: makeBufferedLog('warn'),
+    error: makeBufferedLog('error'),
+    log: (input) => makeBufferedLog(input.level ?? 'debug')(input),
+    getRecentEvents: () => [...preInitBuffer],
+    currentFilePath: () => '',
+  };
+
+  Object.defineProperty(noopLogger, '__flush', {
+    value: flushToLogger,
+    writable: false,
+    enumerable: false,
+  });
+
+  return noopLogger;
+}
+
+debugLogger = createNoopLogger();
 
 export function initDebugLogger(debugDir: string): DebugLogger {
-  debugLogger = createDebugLogger({
+  const realLogger = createDebugLogger({
     debugDir,
     console: true,
     onEvent: broadcastDebugEvent,
   });
+
+  const noop = debugLogger as DebugLogger & { __flush?: (logger: DebugLogger) => void };
+  if (noop.__flush) {
+    noop.__flush(realLogger);
+  }
+
+  debugLogger = realLogger;
+  isInitialized = true;
   return debugLogger;
 }
 
 export function getDebugLogger(): DebugLogger {
   return debugLogger;
 }
 
+export function isDebugLoggerInitialized(): boolean {
+  return isInitialized;
+}
+
 function broadcastDebugEvent(event: DebugEvent): void {
   for (const win of BrowserWindow.getAllWindows()) {
     try {

packages/desktop/test/debug/debug-logger.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('electron', () => ({
+  BrowserWindow: {
+    getAllWindows: () => [],
+  },
+}));
+
+describe('debug logger pre-init behavior', () => {
+  beforeEach(async () => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+  });
+
+  it('buffers events before initDebugLogger runs', async () => {
+    const { getDebugLogger, isDebugLoggerInitialized } = await import(
+      '../../src/main/debug/index.js'
+    );
+
+    const logger = getDebugLogger();
+    const event1 = logger.info({ domain: 'app', event: 'test-event-1' });
+    const event2 = logger.error({ domain: 'gateway', event: 'test-event-2' });
+
+    expect(event1.level).toBe('info');
+    expect(event1.domain).toBe('app');
+    expect(event1.event).toBe('test-event-1');
+    expect(event2.level).toBe('error');
+    expect(event2.domain).toBe('gateway');
+
+    expect(getDebugLogger().getRecentEvents()).toHaveLength(2);
+    expect(isDebugLoggerInitialized()).toBe(false);
+  });
+
+  it('flushes buffered events to real logger after init', async () => {
+    const { getDebugLogger, initDebugLogger, isDebugLoggerInitialized } = await import(
+      '../../src/main/debug/index.js'
+    );
+
+    const logger = getDebugLogger();
+
+    logger.info({ domain: 'app', event: 'pre-init-event' });
+    logger.warn({ domain: 'gateway', event: 'pre-init-warn' });
+
+    expect(isDebugLoggerInitialized()).toBe(false);
+
+    const tempDir = `/tmp/test-debug-${Date.now()}`;
+    const realLogger = initDebugLogger(tempDir);
+    expect(isDebugLoggerInitialized()).toBe(true);
+
+    const recentEvents = realLogger.getRecentEvents();
+    expect(recentEvents.some((e) => e.event === 'pre-init-event')).toBe(true);
+    expect(recentEvents.some((e) => e.event === 'pre-init-warn')).toBe(true);
+  });
+
+  it('warns via console when logging before init', async () => {
+    const { getDebugLogger, isDebugLoggerInitialized } = await import(
+      '../../src/main/debug/index.js'
+    );
+
+    if (isDebugLoggerInitialized()) {
+      return;
+    }
+
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    const logger = getDebugLogger();
+    logger.error({ domain: 'app', event: 'pre-init-warning-test' });
+
+    expect(warnSpy).toHaveBeenCalled();
+    const warningCall = warnSpy.mock.calls[0][0] as string;
+    expect(warningCall).toContain('[debug] Logger not initialized yet');
+
+    warnSpy.mockRestore();
+  });
+});