Merge branch 'develop' into feature/multi-step-enhancements

Author: wtfsayo

.gitignore

@@ -185,3 +185,7 @@ tsconfig.tsbuildinfo
 test-data/
 standalone.ts
 /.claude
+
+# Continuous Claude cache (local only)
+.claude/cache/
+/thoughts

CLAUDE.md

@@ -255,6 +255,8 @@ elizaos test -t component     # Run only component tests
 elizaos test -t e2e          # Run only e2e tests
 elizaos test --name "test"   # Filter tests by name (case sensitive)
 elizaos test --skip-build    # Skip building before tests
+elizaos test --port <port>   # Port for e2e tests
+elizaos test --skip-type-check  # Skip TypeScript validation
 ```
 
 **Test Types:**

packages/cli/src/commands/deploy/utils/docker-build.ts

@@ -6,7 +6,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { logger } from '@elizaos/core';
-import { execa } from 'execa';
+import { bunExec } from '../../../utils/bun-exec';
 import crypto from 'node:crypto';
 import ora from 'ora';
 
@@ -49,9 +49,10 @@ export interface DockerPushResult {
  */
 export async function checkDockerAvailable(): Promise<boolean> {
   try {
-    await execa('docker', ['--version']);
-    await execa('docker', ['info']);
-    return true;
+    const versionResult = await bunExec('docker', ['--version']);
+    if (!versionResult.success) return false;
+    const infoResult = await bunExec('docker', ['info']);
+    return infoResult.success;
   } catch {
     return false;
   }
@@ -196,13 +197,22 @@ export async function buildDockerImage(options: DockerBuildOptions): Promise<Doc
 
     // Execute Docker build
     const startTime = Date.now();
-    const { stdout } = await execa('docker', buildArgs, {
+    const buildResult = await bunExec('docker', buildArgs, {
       env: {
-        ...process.env,
         DOCKER_DEFAULT_PLATFORM: platform,
         DOCKER_BUILDKIT: '1',
       },
     });
+
+    if (!buildResult.success) {
+      return {
+        success: false,
+        imageTag: options.imageTag,
+        error: buildResult.stderr || 'Docker build failed',
+      };
+    }
+
+    const stdout = buildResult.stdout;
     const buildTime = Date.now() - startTime;
 
     logger.debug(
@@ -216,12 +226,20 @@ export async function buildDockerImage(options: DockerBuildOptions): Promise<Doc
     }
 
     // Get image info
-    const inspectResult = await execa('docker', [
+    const inspectResult = await bunExec('docker', [
       'inspect',
       options.imageTag,
       '--format={{.Id}}|{{.Size}}',
     ]);
 
+    if (!inspectResult.success) {
+      return {
+        success: false,
+        imageTag: options.imageTag,
+        error: inspectResult.stderr || 'Failed to inspect Docker image',
+      };
+    }
+
     const [imageId, sizeStr] = inspectResult.stdout.split('|');
     const size = parseInt(sizeStr, 10);
 
@@ -272,11 +290,26 @@ async function loginToECR(registryUrl: string, authToken: string): Promise<void>
     'Logging in to ECR registry'
   );
 
-  // Docker login
-  await execa('docker', ['login', '--username', username, '--password-stdin', cleanRegistryUrl], {
-    input: password,
+  // Docker login - use Bun.spawn directly for stdin input
+  const proc = Bun.spawn(['docker', 'login', '--username', username, '--password-stdin', cleanRegistryUrl], {
+    stdin: 'pipe',
+    stdout: 'pipe',
+    stderr: 'pipe',
   });
 
+  // Write password to stdin using FileSink API
+  if (proc.stdin) {
+    proc.stdin.write(password);
+    proc.stdin.end();
+  }
+
+  const exitCode = await proc.exited;
+
+  if (exitCode !== 0) {
+    const stderr = await new Response(proc.stderr).text();
+    throw new Error(`Docker login failed: ${stderr}`);
+  }
+
   logger.info({ src: 'cli', util: 'docker-build' }, 'Logged in to ECR');
 }
 
@@ -286,7 +319,11 @@ async function loginToECR(registryUrl: string, authToken: string): Promise<void>
 async function tagImageForECR(localTag: string, ecrImageUri: string): Promise<void> {
   logger.info({ src: 'cli', util: 'docker-build', ecrImageUri }, 'Tagging image for ECR');
 
-  await execa('docker', ['tag', localTag, ecrImageUri]);
+  const result = await bunExec('docker', ['tag', localTag, ecrImageUri]);
+
+  if (!result.success) {
+    throw new Error(`Failed to tag image: ${result.stderr}`);
+  }
 
   logger.debug({ src: 'cli', util: 'docker-build', localTag, ecrImageUri }, 'Image tagged for ECR');
 }
@@ -338,66 +375,90 @@ export async function pushDockerImage(options: DockerPushOptions): Promise<Docke
     let completedLayers = 0;
     const layerProgress = new Map<string, { current: number; total: number }>();
 
-    const pushProcess = execa('docker', ['push', ecrImageUri]);
+    // Use Bun.spawn for the push process with streaming stderr
+    const pushProcess = Bun.spawn(['docker', 'push', ecrImageUri], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
 
-    // Track progress from stderr (Docker outputs progress to stderr)
-    if (pushProcess.stderr) {
-      pushProcess.stderr.on('data', (data: Buffer) => {
-        const output = data.toString();
+    // Process stderr stream for progress tracking
+    const processStderr = async () => {
+      if (!pushProcess.stderr) return;
 
-        // Parse Docker layer progress
-        // Format: "layer-id: Pushing [==>     ] 15.5MB/100MB"
-        const lines = output.split('\n');
+      const reader = pushProcess.stderr.getReader();
+      const decoder = new TextDecoder();
 
-        for (const line of lines) {
-          const layerMatch = line.match(
-            /^([a-f0-9]+):\s*(\w+)\s*\[([=>]+)\s*\]\s+([\d.]+)([KMGT]?B)\/([\d.]+)([KMGT]?B)/
-          );
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
 
-          if (layerMatch) {
-            const [, layerId, , , currentStr, currentUnit, totalStr, totalUnit] = layerMatch;
+          const output = decoder.decode(value, { stream: true });
 
-            // Convert to bytes for accurate progress
-            const current = parseSize(currentStr, currentUnit);
-            const total = parseSize(totalStr, totalUnit);
+          // Parse Docker layer progress
+          // Format: "layer-id: Pushing [==>     ] 15.5MB/100MB"
+          const lines = output.split('\n');
 
-            layerProgress.set(layerId, { current, total });
+          for (const line of lines) {
+            const layerMatch = line.match(
+              /^([a-f0-9]+):\s*(\w+)\s*\[([=>]+)\s*\]\s+([\d.]+)([KMGT]?B)\/([\d.]+)([KMGT]?B)/
+            );
 
-            // Calculate overall progress
-            let totalBytes = 0;
-            let uploadedBytes = 0;
+            if (layerMatch) {
+              const [, layerId, , , currentStr, currentUnit, totalStr, totalUnit] = layerMatch;
 
-            for (const [, progress] of layerProgress) {
-              totalBytes += progress.total;
-              uploadedBytes += progress.current;
-            }
+              // Convert to bytes for accurate progress
+              const current = parseSize(currentStr, currentUnit);
+              const total = parseSize(totalStr, totalUnit);
 
-            const overallPercent =
-              totalBytes > 0 ? Math.floor((uploadedBytes / totalBytes) * 100) : 0;
-            const uploadedMB = (uploadedBytes / 1024 / 1024).toFixed(1);
-            const totalMB = (totalBytes / 1024 / 1024).toFixed(1);
+              layerProgress.set(layerId, { current, total });
 
-            spinner.text = `Pushing to ECR... ${overallPercent}% (${uploadedMB}/${totalMB} MB, ${layerProgress.size} layers)`;
-          }
+              // Calculate overall progress
+              let totalBytes = 0;
+              let uploadedBytes = 0;
 
-          // Check for pushed layers
-          if (line.includes(': Pushed')) {
-            completedLayers++;
-          }
+              for (const [, progress] of layerProgress) {
+                totalBytes += progress.total;
+                uploadedBytes += progress.current;
+              }
+
+              const overallPercent =
+                totalBytes > 0 ? Math.floor((uploadedBytes / totalBytes) * 100) : 0;
+              const uploadedMB = (uploadedBytes / 1024 / 1024).toFixed(1);
+              const totalMB = (totalBytes / 1024 / 1024).toFixed(1);
 
-          // Check for completion digest
-          const digestMatch = line.match(/digest: (sha256:[a-f0-9]+)/);
-          if (digestMatch) {
-            imageDigest = digestMatch[1];
+              spinner.text = `Pushing to ECR... ${overallPercent}% (${uploadedMB}/${totalMB} MB, ${layerProgress.size} layers)`;
+            }
+
+            // Check for pushed layers
+            if (line.includes(': Pushed')) {
+              completedLayers++;
+            }
+
+            // Check for completion digest
+            const digestMatch = line.match(/digest: (sha256:[a-f0-9]+)/);
+            if (digestMatch) {
+              imageDigest = digestMatch[1];
+            }
           }
         }
-      });
-    }
+      } catch {
+        // Ignore stream errors during processing
+      }
+    };
 
     try {
-      await pushProcess;
+      // Process stderr in parallel with waiting for exit
+      await Promise.all([processStderr(), pushProcess.exited]);
+
+      const exitCode = pushProcess.exitCode;
       const pushTime = Date.now() - startTime;
 
+      if (exitCode !== 0) {
+        spinner.fail('Failed to push image to ECR');
+        throw new Error('Docker push failed');
+      }
+
       spinner.succeed(
         `Image pushed in ${(pushTime / 1000).toFixed(1)}s (${completedLayers} layers)`
       );
@@ -477,8 +538,15 @@ export async function cleanupLocalImages(imageTags: string[]): Promise<void> {
   );
 
   try {
-    await execa('docker', ['rmi', ...imageTags, '--force']);
-    logger.info({ src: 'cli', util: 'docker-build' }, 'Local images cleaned up');
+    const result = await bunExec('docker', ['rmi', ...imageTags, '--force']);
+    if (result.success) {
+      logger.info({ src: 'cli', util: 'docker-build' }, 'Local images cleaned up');
+    } else {
+      logger.warn(
+        { src: 'cli', util: 'docker-build', error: result.stderr },
+        'Failed to clean up some images'
+      );
+    }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     logger.warn(

packages/cli/src/commands/report/src/__tests__/integration.test.ts

@@ -11,7 +11,6 @@
 import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
 import { promises as fs } from 'fs';
 import { join } from 'path';
-import { execSync } from 'child_process';
 import { tmpdir } from 'os';
 import { executeGenerateCommand } from '../../generate';
 import { ScenarioRunResult } from '../../../scenario/src/schema';

packages/cli/src/commands/tee/phala-wrapper.ts

@@ -1,5 +1,4 @@
 import { Command } from 'commander';
-import { spawn } from 'node:child_process';
 import { logger } from '@elizaos/core';
 import { emoji } from '../../utils/emoji-handler';
 
@@ -30,42 +29,45 @@ export const phalaCliCommand = new Command('phala')
       logger.info({ src: 'cli', command: 'tee-phala', args }, 'Running Phala CLI command');
 
       // Use npx with --yes flag to auto-install without prompting
-      // Security fix: Remove shell: true as args are already properly escaped as array
-      const phalaProcess = spawn('npx', ['--yes', 'phala', ...args], {
-        stdio: 'inherit',
-      });
+      // Using Bun.spawn for process execution per project guidelines
+      const phalaProcess = Bun.spawn(['npx', '--yes', 'phala', ...args], {
+        stdio: ['inherit', 'inherit', 'inherit'],
+        onExit(_proc, exitCode, _signalCode, error) {
+          if (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(
+              { src: 'cli', command: 'tee-phala', error: errorMessage, args },
+              'Failed to execute Phala CLI'
+            );
 
-      phalaProcess.on('error', (err) => {
-        const error = err as NodeJS.ErrnoException;
-        logger.error(
-          { src: 'cli', command: 'tee-phala', error: error.message, args },
-          'Failed to execute Phala CLI'
-        );
+            // Check if it's an ENOENT-like error (command not found)
+            if (errorMessage.includes('ENOENT') || errorMessage.includes('not found')) {
+              console.error(
+                `\n${emoji.error('Error: npx not found. Please install Node.js and npm:')}`
+              );
+              console.error('   Visit https://nodejs.org or use a version manager like nvm');
+              console.error(
+                '   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash'
+              );
+            } else {
+              console.error(`\n${emoji.error('Error: Failed to execute Phala CLI')}`);
+              console.error('   Try running directly: npx phala [args]');
+            }
+            process.exit(1);
+          }
 
-        if (error.code === 'ENOENT') {
-          console.error(
-            `\n${emoji.error('Error: npx not found. Please install Node.js and npm:')}`
-          );
-          console.error('   Visit https://nodejs.org or use a version manager like nvm');
-          console.error(
-            '   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash'
-          );
-        } else {
-          console.error(`\n${emoji.error('Error: Failed to execute Phala CLI')}`);
-          console.error('   Try running directly: npx phala [args]');
-        }
-        process.exit(1);
+          if (exitCode !== 0) {
+            logger.warn(
+              { src: 'cli', command: 'tee-phala', code: exitCode },
+              'Phala CLI exited with non-zero code'
+            );
+          }
+          process.exit(exitCode || 0);
+        },
       });
 
-      phalaProcess.on('exit', (code) => {
-        if (code !== 0) {
-          logger.warn(
-            { src: 'cli', command: 'tee-phala', code },
-            'Phala CLI exited with non-zero code'
-          );
-        }
-        process.exit(code || 0);
-      });
+      // Wait for the process to complete
+      await phalaProcess.exited;
     } catch (error) {
       logger.error(
         {

packages/core/README.md

@@ -48,7 +48,7 @@ The correct build is automatically selected based on your environment through pa
 npm install buffer crypto-browserify stream-browserify events
 ```
 
-For more details on the dual build system, see [BUILD_SYSTEM.md](./BUILD_SYSTEM.md).
+The dual build system uses conditional exports in package.json to automatically select the appropriate build based on the runtime environment.
 
 ## Configuration