dynamic file input

Author: alexanderkirtzel

packages/cli/README.md

@@ -33,6 +33,9 @@ walkeros bundle flow.json
 # Test with simulated events (no real API calls)
 walkeros simulate flow.json --event '{"name":"product view"}'
 
+# Or test a pre-built bundle directly
+walkeros simulate dist/bundle.mjs --event '{"name":"product view"}'
+
 # Push real events to destinations
 walkeros push flow.json --event '{"name":"product view"}'
 
@@ -78,42 +81,74 @@ The output path uses convention-based defaults: `./dist/bundle.mjs` for server,
 
 ### simulate
 
-Test event processing with simulated events.
+Test event processing with simulated events. Accepts either a config JSON (which
+gets bundled) or a pre-built bundle (executed directly).
 
 ```bash
-walkeros simulate <config-file> --event '{"name":"page view"}' [options]
+walkeros simulate <input> --event '{"name":"page view"}' [options]
 ```
 
+**Input types:**
+
+- **Config JSON** - Bundled and executed with destination mocking
+- **Pre-built bundle** (`.js`/`.mjs`) - Executed directly, no mocking
+
+The CLI auto-detects the input type by attempting to parse as JSON.
+
 **Options:**
 
 - `-e, --event <json>` - Event JSON string (required)
+- `-p, --platform <platform>` - Platform override (`web` or `server`)
 - `--json` - Output results as JSON
 - `-v, --verbose` - Verbose output
 
-**Example:**
+**Examples:**
 
 ```bash
-# Simulate page view
-walkeros simulate \
-  examples/web-serve.json \
+# Simulate with config (auto-bundled)
+walkeros simulate examples/web-serve.json \
   --event '{"name":"page view","data":{"title":"Home"}}' \
   --json
+
+# Simulate with pre-built bundle
+walkeros simulate dist/bundle.mjs --event '{"name":"page view"}'
+
+# Override platform detection
+walkeros simulate dist/bundle.js --platform server --event '{"name":"page view"}'
 ```
 
+**Platform detection:**
+
+When using pre-built bundles, platform is detected from file extension:
+
+- `.mjs` → server (ESM, Node.js)
+- `.js` → web (IIFE, JSDOM)
+
+Use `--platform` to override if extension doesn't match intended runtime.
+
 ### push
 
 Execute your flow with real API calls to configured destinations. Unlike
-`simulate` which mocks API calls, `push` performs actual HTTP requests.
+`simulate` which mocks API calls, `push` performs actual HTTP requests. Accepts
+either a config JSON (which gets bundled) or a pre-built bundle.
 
 ```bash
-walkeros push <config-file> --event '<json>' [options]
+walkeros push <input> --event '<json>' [options]
 ```
 
+**Input types:**
+
+- **Config JSON** - Bundled and executed
+- **Pre-built bundle** (`.js`/`.mjs`) - Executed directly
+
+The CLI auto-detects the input type by attempting to parse as JSON.
+
 **Options:**
 
 - `-e, --event <source>` - Event to push (JSON string, file path, or URL)
   **Required**
 - `--flow <name>` - Flow name (for multi-flow configs)
+- `-p, --platform <platform>` - Platform override (`web` or `server`)
 - `--json` - Output results as JSON
 - `-v, --verbose` - Verbose output
 - `-s, --silent` - Suppress output (for CI/CD)
@@ -131,6 +166,16 @@ walkeros push flow.json --event ./events/order.json
 walkeros push flow.json --event https://example.com/sample-event.json
 ```
 
+**Bundle input:**
+
+```bash
+# Push with pre-built bundle
+walkeros push dist/bundle.mjs --event '{"name":"order complete"}'
+
+# Override platform detection
+walkeros push dist/bundle.js --platform server --event '{"name":"order complete"}'
+```
+
 **Push vs Simulate:**
 
 | Feature      | `push`                              | `simulate`         |

packages/cli/src/__tests__/cli-e2e.test.ts

@@ -89,7 +89,8 @@ describe('CLI E2E Tests', () => {
       const result = await runCLI(['simulate', '/invalid/path.json']);
 
       expect(result.code).not.toBe(0);
-      expect(result.stderr || result.stdout).toContain('not found');
+      // Node.js file errors use "no such file or directory" or "ENOENT"
+      expect(result.stderr || result.stdout).toMatch(/no such file|ENOENT/i);
     }, 10000);
   });
 

packages/cli/src/commands/push/index.ts

@@ -6,7 +6,9 @@ import { schemas } from '@walkeros/core/dev';
 import {
   createCommandLogger,
   getErrorMessage,
+  detectInput,
   type Logger,
+  type Platform,
 } from '../../core/index.js';
 import { loadFlowConfig, loadJsonFromSource } from '../../config/index.js';
 import { bundleCore } from '../bundle/bundler.js';
@@ -18,6 +20,7 @@ import type { PushCommandOptions, PushResult } from './types.js';
 export async function pushCommand(options: PushCommandOptions): Promise<void> {
   const logger = createCommandLogger(options);
   const startTime = Date.now();
+  let tempDir: string | undefined;
 
   try {
     // Step 1: Load event
@@ -56,60 +59,36 @@ export async function pushCommand(options: PushCommandOptions): Promise<void> {
       );
     }
 
-    // Step 2: Load config
-    logger.debug('Loading flow configuration');
-    const { flowConfig, buildOptions } = await loadFlowConfig(options.config, {
-      flowName: options.flow,
-      logger,
-    });
-
-    const platform = getPlatform(flowConfig);
-
-    // Step 3: Bundle to temp file in config directory (so Node.js can find node_modules)
-    logger.debug('Bundling flow configuration');
-    // buildOptions.configDir already handles URLs (uses cwd) vs local paths
-    const configDir = buildOptions.configDir || process.cwd();
-    const tempDir = path.join(
-      configDir,
-      '.tmp',
-      `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
-    );
-    await fs.ensureDir(tempDir);
-    const tempPath = path.join(
-      tempDir,
-      `bundle.${platform === 'web' ? 'js' : 'mjs'}`,
-    );
-
-    const pushBuildOptions = {
-      ...buildOptions,
-      output: tempPath,
-      // Web uses IIFE for browser-like execution, server uses ESM
-      format: platform === 'web' ? ('iife' as const) : ('esm' as const),
-      platform: platform === 'web' ? ('browser' as const) : ('node' as const),
-      ...(platform === 'web' && {
-        windowCollector: 'collector',
-        windowElb: 'elb',
-      }),
-    };
-
-    await bundleCore(flowConfig, pushBuildOptions, logger, false);
-
-    logger.debug(`Bundle created: ${tempPath}`);
+    // Step 2: Detect input type (config or bundle)
+    logger.debug('Detecting input type');
+    const detected = await detectInput(options.config, options.platform);
 
-    // Step 4: Execute based on platform
     let result: PushResult;
 
-    if (platform === 'web') {
-      logger.debug('Executing in web environment (JSDOM)');
-      result = await executeWebPush(tempPath, validatedEvent, logger);
-    } else if (platform === 'server') {
-      logger.debug('Executing in server environment (Node.js)');
-      result = await executeServerPush(tempPath, validatedEvent, logger);
+    if (detected.type === 'config') {
+      // Config flow: load config, bundle, execute
+      result = await executeConfigPush(
+        options,
+        validatedEvent,
+        logger,
+        (dir) => {
+          tempDir = dir;
+        },
+      );
     } else {
-      throw new Error(`Unsupported platform: ${platform}`);
+      // Bundle flow: execute directly
+      result = await executeBundlePush(
+        detected.content,
+        detected.platform!,
+        validatedEvent,
+        logger,
+        (dir) => {
+          tempDir = dir;
+        },
+      );
     }
 
-    // Step 5: Output results
+    // Step 3: Output results
     const duration = Date.now() - startTime;
 
     if (options.json) {
@@ -143,13 +122,6 @@ export async function pushCommand(options: PushCommandOptions): Promise<void> {
         process.exit(1);
       }
     }
-
-    // Cleanup temp directory
-    try {
-      await fs.remove(tempDir);
-    } catch {
-      // Ignore cleanup errors
-    }
   } catch (error) {
     const duration = Date.now() - startTime;
     const errorMessage = getErrorMessage(error);
@@ -165,6 +137,109 @@ export async function pushCommand(options: PushCommandOptions): Promise<void> {
     }
 
     process.exit(1);
+  } finally {
+    // Cleanup temp directory
+    if (tempDir) {
+      await fs.remove(tempDir).catch(() => {
+        // Ignore cleanup errors
+      });
+    }
+  }
+}
+
+/**
+ * Execute push from config JSON (existing behavior)
+ */
+async function executeConfigPush(
+  options: PushCommandOptions,
+  validatedEvent: { name: string; data: Record<string, unknown> },
+  logger: Logger,
+  setTempDir: (dir: string) => void,
+): Promise<PushResult> {
+  // Load config
+  logger.debug('Loading flow configuration');
+  const { flowConfig, buildOptions } = await loadFlowConfig(options.config, {
+    flowName: options.flow,
+    logger,
+  });
+
+  const platform = getPlatform(flowConfig);
+
+  // Bundle to temp file in config directory (so Node.js can find node_modules)
+  logger.debug('Bundling flow configuration');
+  const configDir = buildOptions.configDir || process.cwd();
+  const tempDir = path.join(
+    configDir,
+    '.tmp',
+    `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+  );
+  setTempDir(tempDir);
+  await fs.ensureDir(tempDir);
+  const tempPath = path.join(
+    tempDir,
+    `bundle.${platform === 'web' ? 'js' : 'mjs'}`,
+  );
+
+  const pushBuildOptions = {
+    ...buildOptions,
+    output: tempPath,
+    format: platform === 'web' ? ('iife' as const) : ('esm' as const),
+    platform: platform === 'web' ? ('browser' as const) : ('node' as const),
+    ...(platform === 'web' && {
+      windowCollector: 'collector',
+      windowElb: 'elb',
+    }),
+  };
+
+  await bundleCore(flowConfig, pushBuildOptions, logger, false);
+
+  logger.debug(`Bundle created: ${tempPath}`);
+
+  // Execute based on platform
+  if (platform === 'web') {
+    logger.debug('Executing in web environment (JSDOM)');
+    return executeWebPush(tempPath, validatedEvent, logger);
+  } else if (platform === 'server') {
+    logger.debug('Executing in server environment (Node.js)');
+    return executeServerPush(tempPath, validatedEvent, logger);
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+}
+
+/**
+ * Execute push from pre-built bundle
+ */
+async function executeBundlePush(
+  bundleContent: string,
+  platform: Platform,
+  validatedEvent: { name: string; data: Record<string, unknown> },
+  logger: Logger,
+  setTempDir: (dir: string) => void,
+): Promise<PushResult> {
+  // Write bundle to temp file
+  const tempDir = path.join(
+    process.cwd(),
+    '.tmp',
+    `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+  );
+  setTempDir(tempDir);
+  await fs.ensureDir(tempDir);
+  const tempPath = path.join(
+    tempDir,
+    `bundle.${platform === 'server' ? 'mjs' : 'js'}`,
+  );
+  await fs.writeFile(tempPath, bundleContent, 'utf8');
+
+  logger.debug(`Bundle written to: ${tempPath}`);
+
+  // Execute based on platform
+  if (platform === 'web') {
+    logger.debug('Executing in web environment (JSDOM)');
+    return executeWebPush(tempPath, validatedEvent, logger);
+  } else {
+    logger.debug('Executing in server environment (Node.js)');
+    return executeServerPush(tempPath, validatedEvent, logger);
   }
 }
 

packages/cli/src/commands/push/types.ts

@@ -10,6 +10,7 @@ export interface PushCommandOptions {
   json?: boolean;
   verbose?: boolean;
   silent?: boolean;
+  platform?: 'web' | 'server';
 }
 
 /**