logger

alexanderkirtzel · alexanderkirtzel · commit e49ad41b34e0 · 2025-12-20T00:01:19.000+01:00
diff --git a/packages/cli/src/commands/bundle/bundler.ts b/packages/cli/src/commands/bundle/bundler.ts
@@ -823,6 +823,11 @@ export function generatePlatformWrapper(
 
     return `export default async function(context = {}) {
   const config = ${configObject};${codeSection}
+  // Apply context overrides (e.g., logger config from CLI)
+  if (context.logger) {
+    config.logger = { ...config.logger, ...context.logger };
+  }
+
   return await startFlow(config);
 }`;
   }
diff --git a/packages/cli/src/commands/push/index.ts b/packages/cli/src/commands/push/index.ts
@@ -1,10 +1,15 @@
 import path from 'path';
 import { JSDOM, VirtualConsole } from 'jsdom';
 import fs from 'fs-extra';
-import { getPlatform, type Elb } from '@walkeros/core';
+import {
+  getPlatform,
+  type Elb,
+  type Logger as CoreLogger,
+} from '@walkeros/core';
 import { schemas } from '@walkeros/core/dev';
 import {
   createCommandLogger,
+  createCollectorLoggerConfig,
   getErrorMessage,
   detectInput,
   type Logger,
@@ -77,6 +82,10 @@ export async function pushCommand(options: PushCommandOptions): Promise<void> {
       );
     } else {
       // Bundle flow: execute directly
+      const collectorLoggerConfig = createCollectorLoggerConfig(
+        logger,
+        options.verbose,
+      );
       result = await executeBundlePush(
         detected.content,
         detected.platform!,
@@ -85,6 +94,7 @@ export async function pushCommand(options: PushCommandOptions): Promise<void> {
         (dir) => {
           tempDir = dir;
         },
+        { logger: collectorLoggerConfig },
       );
     }
 
@@ -201,7 +211,13 @@ async function executeConfigPush(
     return executeWebPush(tempPath, validatedEvent, logger);
   } else if (platform === 'server') {
     logger.debug('Executing in server environment (Node.js)');
-    return executeServerPush(tempPath, validatedEvent, logger);
+    const collectorLoggerConfig = createCollectorLoggerConfig(
+      logger,
+      options.verbose,
+    );
+    return executeServerPush(tempPath, validatedEvent, logger, 60000, {
+      logger: collectorLoggerConfig,
+    });
   } else {
     throw new Error(`Unsupported platform: ${platform}`);
   }
@@ -216,6 +232,7 @@ async function executeBundlePush(
   validatedEvent: { name: string; data: Record<string, unknown> },
   logger: Logger,
   setTempDir: (dir: string) => void,
+  context: { logger?: CoreLogger.Config } = {},
 ): Promise<PushResult> {
   // Write bundle to temp file
   const tempDir = path.join(
@@ -239,7 +256,7 @@ async function executeBundlePush(
     return executeWebPush(tempPath, validatedEvent, logger);
   } else {
     logger.debug('Executing in server environment (Node.js)');
-    return executeServerPush(tempPath, validatedEvent, logger);
+    return executeServerPush(tempPath, validatedEvent, logger, 60000, context);
   }
 }
 
@@ -280,23 +297,28 @@ async function executeWebPush(
     const bundleCode = await fs.readFile(bundlePath, 'utf8');
     window.eval(bundleCode);
 
-    // Wait for window.elb assignment
-    logger.debug('Waiting for elb...');
+    // Wait for window.collector assignment
+    logger.debug('Waiting for collector...');
     await waitForWindowProperty(
       window as unknown as Record<string, unknown>,
-      'elb',
+      'collector',
       5000,
     );
 
     const windowObj = window as unknown as Record<string, unknown>;
-    const elb = windowObj.elb as unknown as (
-      name: string,
-      data: Record<string, unknown>,
-    ) => Promise<Elb.PushResult>;
+    const collector = windowObj.collector as unknown as {
+      push: (event: {
+        name: string;
+        data: Record<string, unknown>;
+      }) => Promise<Elb.PushResult>;
+    };
 
-    // Push event
+    // Push event directly to collector (bypasses source handlers)
     logger.log(`Pushing event: ${event.name}`);
-    const elbResult = await elb(event.name, event.data);
+    const elbResult = await collector.push({
+      name: event.name,
+      data: event.data,
+    });
 
     return {
       success: true,
@@ -320,6 +342,7 @@ async function executeServerPush(
   event: PushEventInput,
   logger: Logger,
   timeout: number = 60000, // 60 second default timeout
+  context: { logger?: CoreLogger.Config } = {},
 ): Promise<PushResult> {
   const startTime = Date.now();
 
@@ -342,26 +365,28 @@ async function executeServerPush(
         throw new Error('Bundle does not export default factory function');
       }
 
-      // Call factory function to start flow
+      // Call factory function to start flow (pass context for verbose logging)
       logger.debug('Calling factory function...');
-      const result = await flowModule.default();
+      const result = await flowModule.default(context);
 
-      if (!result || !result.elb || typeof result.elb !== 'function') {
+      if (
+        !result ||
+        !result.collector ||
+        typeof result.collector.push !== 'function'
+      ) {
         throw new Error(
-          'Factory function did not return valid result with elb',
+          'Factory function did not return valid result with collector',
         );
       }
 
-      const { elb } = result;
+      const { collector } = result;
 
-      // Push event
+      // Push event directly to collector (bypasses source handlers)
       logger.log(`Pushing event: ${event.name}`);
-      const elbResult = await (
-        elb as (
-          name: string,
-          data: Record<string, unknown>,
-        ) => Promise<Elb.PushResult>
-      )(event.name, event.data);
+      const elbResult = await collector.push({
+        name: event.name,
+        data: event.data,
+      });
 
       return {
         success: true,
diff --git a/packages/cli/src/commands/run/execution.ts b/packages/cli/src/commands/run/execution.ts
@@ -1,10 +1,11 @@
-import { createLogger, Level } from '@walkeros/core';
+import { createLogger, Level, type Logger } from '@walkeros/core';
 import type { RuntimeConfig, ServeConfig } from '../../runtime/index.js';
 import { runFlow, runServeMode } from '../../runtime/index.js';
 
 // Create logger for local execution - DEBUG level when VERBOSE, otherwise INFO
 const logLevel = process.env.VERBOSE === 'true' ? Level.DEBUG : Level.INFO;
-const logger = createLogger({ level: logLevel });
+const loggerConfig: Logger.Config = { level: logLevel };
+const logger = createLogger(loggerConfig);
 
 /**
  * Execute run command locally
@@ -32,7 +33,7 @@ export async function executeRunLocal(
         port: options.port,
         host: options.host,
       };
-      await runFlow(flowPath, config, logger.scope('runner'));
+      await runFlow(flowPath, config, logger.scope('runner'), loggerConfig);
       break;
     }
 
diff --git a/packages/cli/src/commands/simulate/node-executor.ts b/packages/cli/src/commands/simulate/node-executor.ts
@@ -5,7 +5,7 @@
  */
 
 import { pathToFileURL } from 'url';
-import type { Elb } from '@walkeros/core';
+import type { Elb, Logger as CoreLogger } from '@walkeros/core';
 import { getErrorMessage } from '../../core/index.js';
 import type { CallTracker, ApiCall } from './tracker.js';
 
@@ -83,6 +83,7 @@ export async function executeInNode(
   tracker: CallTracker,
   envs: Record<string, DestinationEnv>,
   timeout: number = 30000,
+  context: { logger?: CoreLogger.Config } = {},
 ): Promise<ExecutionResult> {
   const start = Date.now();
 
@@ -103,21 +104,27 @@ export async function executeInNode(
         throw new Error('Bundle does not export default factory function');
       }
 
-      const result = await module.default();
+      const result = await module.default(context);
 
-      if (!result || !result.elb || typeof result.elb !== 'function') {
+      if (
+        !result ||
+        !result.collector ||
+        typeof result.collector.push !== 'function'
+      ) {
         throw new Error(
-          'Factory function did not return valid result with elb',
+          'Factory function did not return valid result with collector',
         );
       }
 
       const { collector, elb } = result;
 
       let elbResult: Elb.PushResult | undefined;
       try {
-        elbResult = (await elb(event.name, event.data)) as
-          | Elb.PushResult
-          | undefined;
+        // Use collector.push directly (bypasses source handlers, same as push command)
+        elbResult = await collector.push({
+          name: event.name,
+          data: event.data,
+        });
       } catch (error) {
         throw new Error(`Event execution failed: ${getErrorMessage(error)}`);
       }
diff --git a/packages/cli/src/commands/simulate/simulator.ts b/packages/cli/src/commands/simulate/simulator.ts
@@ -1,11 +1,13 @@
 import path from 'path';
 import fs from 'fs-extra';
-import type { Flow } from '@walkeros/core';
+import type { Flow, Logger as CoreLogger } from '@walkeros/core';
 import { getPlatform } from '@walkeros/core';
 import {
   createLogger,
+  createCollectorLoggerConfig,
   getErrorMessage,
   detectInput,
+  type Logger,
   type Platform,
 } from '../../core/index.js';
 import {
@@ -48,7 +50,10 @@ export async function simulateCore(
   try {
     // Execute simulation
     logger.debug(`Simulating event: ${JSON.stringify(event)}`);
-    const result = await executeSimulation(event, inputPath, options.platform);
+    const result = await executeSimulation(event, inputPath, options.platform, {
+      logger,
+      verbose: options.verbose,
+    });
 
     return result;
   } catch (error) {
@@ -92,10 +97,16 @@ export async function executeSimulation(
   event: unknown,
   inputPath: string,
   platformOverride?: Platform,
+  options: { logger?: Logger; verbose?: boolean } = {},
 ): Promise<SimulationResult> {
   const startTime = Date.now();
   const tempDir = getTmpPath();
 
+  // Create collector logger config for forwarding logs
+  const collectorLoggerConfig = options.logger
+    ? createCollectorLoggerConfig(options.logger, options.verbose)
+    : undefined;
+
   try {
     // Ensure temp directory exists
     await fs.ensureDir(tempDir);
@@ -124,6 +135,7 @@ export async function executeSimulation(
         typedEvent,
         tempDir,
         startTime,
+        collectorLoggerConfig,
       );
     } else {
       // Bundle flow: execute directly without mocking
@@ -133,6 +145,7 @@ export async function executeSimulation(
         typedEvent,
         tempDir,
         startTime,
+        collectorLoggerConfig,
       );
     }
   } catch (error) {
@@ -161,6 +174,7 @@ async function executeConfigSimulation(
   typedEvent: { name: string; data?: unknown },
   tempDir: string,
   startTime: number,
+  loggerConfig?: CoreLogger.Config,
 ): Promise<SimulationResult> {
   // Load config
   const { flowConfig, buildOptions } = await loadFlowConfig(configPath);
@@ -230,6 +244,7 @@ async function executeConfigSimulation(
       tracker,
       envs,
       30000,
+      loggerConfig ? { logger: loggerConfig } : {},
     );
   }
 
@@ -253,6 +268,7 @@ async function executeBundleSimulation(
   typedEvent: { name: string; data?: unknown },
   tempDir: string,
   startTime: number,
+  loggerConfig?: CoreLogger.Config,
 ): Promise<SimulationResult> {
   // Write bundle to temp file
   const tempOutput = path.join(
@@ -283,6 +299,7 @@ async function executeBundleSimulation(
       tracker,
       {},
       30000,
+      loggerConfig ? { logger: loggerConfig } : {},
     );
   }
 
diff --git a/packages/cli/src/core/collector-logger.ts b/packages/cli/src/core/collector-logger.ts
@@ -0,0 +1,35 @@
+import type { Logger as CoreLogger } from '@walkeros/core';
+import type { Logger } from './logger.js';
+
+/**
+ * Create collector logger config that forwards to CLI logger
+ *
+ * This bridges the CLI logger with the collector's internal logger,
+ * allowing collector logs (from destinations, sources, etc.) to be
+ * displayed through the CLI's output system.
+ *
+ * @param cliLogger - The CLI logger instance
+ * @param verbose - Whether verbose mode is enabled
+ * @returns Logger config for the collector
+ */
+export function createCollectorLoggerConfig(
+  cliLogger: Logger,
+  verbose?: boolean,
+): CoreLogger.Config {
+  return {
+    level: verbose ? 'DEBUG' : 'ERROR',
+    handler: (level, message, context, scope) => {
+      const scopePath = scope.length > 0 ? `[${scope.join(':')}] ` : '';
+      const hasContext = Object.keys(context).length > 0;
+      const contextStr = hasContext ? ` ${JSON.stringify(context)}` : '';
+
+      if (level === 0) {
+        // ERROR - always show
+        cliLogger.error(`${scopePath}${message}${contextStr}`);
+      } else if (verbose) {
+        // INFO or DEBUG - only show if verbose
+        cliLogger.debug(`${scopePath}${message}${contextStr}`);
+      }
+    },
+  };
+}
diff --git a/packages/cli/src/core/index.ts b/packages/cli/src/core/index.ts
@@ -1,4 +1,5 @@
 export * from './logger.js';
+export * from './collector-logger.js';
 export * from './timer.js';
 export * from './output.js';
 export * from './tmp.js';
diff --git a/packages/cli/src/runtime/runner.ts b/packages/cli/src/runtime/runner.ts

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`export * from './logger.js';`
	`2`	`+export * from './collector-logger.js';`
`2`	`3`	`export * from './timer.js';`
`3`	`4`	`export * from './output.js';`
`4`	`5`	`export * from './tmp.js';`