zephyr-cli 0.0.3 → 0.1.3-next.6

package/dist/lib/spawn-helper.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeCommand = executeCommand;
+const node_child_process_1 = require("node:child_process");
+/**
+ * Execute a command with full stdio passthrough. All stdin, stdout, and stderr are
+ * proxied between the parent and child process.
+ *
+ * @param parsed - The parsed command to execute
+ * @param cwd - The working directory
+ * @returns Promise that resolves with exit code and signal
+ */
+async function executeCommand(parsed, cwd) {
+    return new Promise((resolve, reject) => {
+        const { command, args, envVars } = parsed;
+        // Merge environment variables
+        const env = Object.assign(Object.assign({}, process.env), envVars);
+        // Spawn the command
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd,
+            env,
+            stdio: 'inherit', // This passes stdin, stdout, and stderr through
+            shell: true, // Use shell to handle complex commands
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code, signal) => {
+            resolve({
+                exitCode: code !== null && code !== void 0 ? code : 1,
+                signal,
+            });
+        });
+    });
+}
+//# sourceMappingURL=spawn-helper.js.map

package/dist/lib/spawn-helper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-helper.js","sourceRoot":"","sources":["../../src/lib/spawn-helper.ts"],"names":[],"mappings":";;AAgBA,wCAgCC;AAhDD,2DAA2C;AAQ3C;;;;;;;GAOG;AACI,KAAK,UAAU,cAAc,CAClC,MAAqB,EACrB,GAAW;IAEX,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACrC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;QAE1C,8BAA8B;QAC9B,MAAM,GAAG,mCACJ,OAAO,CAAC,GAAG,GACX,OAAO,CACX,CAAC;QAEF,oBAAoB;QACpB,MAAM,KAAK,GAAG,IAAA,0BAAK,EAAC,OAAO,EAAE,IAAI,EAAE;YACjC,GAAG;YACH,GAAG;YACH,KAAK,EAAE,SAAS,EAAE,gDAAgD;YAClE,KAAK,EAAE,IAAI,EAAE,uCAAuC;SACrD,CAAC,CAAC;QAEH,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE;YAC1B,MAAM,CAAC,KAAK,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE;YACjC,OAAO,CAAC;gBACN,QAAQ,EAAE,IAAI,aAAJ,IAAI,cAAJ,IAAI,GAAI,CAAC;gBACnB,MAAM;aACP,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/lib/upload.d.ts

@@ -0,0 +1,14 @@
+import type { ZeBuildAssetsMap } from 'zephyr-edge-contract';
+import type { ZephyrEngine } from 'zephyr-agent';
+export interface UploadOptions {
+    zephyr_engine: ZephyrEngine;
+    assetsMap: ZeBuildAssetsMap;
+}
+/**
+ * Orchestrate the upload process:
+ *
+ * 1. Start a new build
+ * 2. Upload assets with build stats
+ * 3. Finish the build
+ */
+export declare function uploadAssets(options: UploadOptions): Promise<void>;

package/dist/lib/upload.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadAssets = uploadAssets;
+const zephyr_agent_1 = require("zephyr-agent");
+const build_stats_1 = require("./build-stats");
+/**
+ * Orchestrate the upload process:
+ *
+ * 1. Start a new build
+ * 2. Upload assets with build stats
+ * 3. Finish the build
+ */
+async function uploadAssets(options) {
+    const { zephyr_engine, assetsMap } = options;
+    try {
+        // Start a new build
+        await zephyr_engine.start_new_build();
+        // Generate build stats
+        const buildStats = await (0, build_stats_1.getBuildStats)(zephyr_engine);
+        // Upload assets and finish the build
+        await zephyr_engine.upload_assets({
+            assetsMap,
+            buildStats,
+        });
+        await zephyr_engine.build_finished();
+    }
+    catch (error) {
+        (0, zephyr_agent_1.logFn)('error', zephyr_agent_1.ZephyrError.format(error));
+        throw error;
+    }
+}
+//# sourceMappingURL=upload.js.map

package/dist/lib/upload.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.js","sourceRoot":"","sources":["../../src/lib/upload.ts"],"names":[],"mappings":";;AAiBA,oCAqBC;AApCD,+CAAkD;AAClD,+CAA8C;AAO9C;;;;;;GAMG;AACI,KAAK,UAAU,YAAY,CAAC,OAAsB;IACvD,MAAM,EAAE,aAAa,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC;IAE7C,IAAI,CAAC;QACH,oBAAoB;QACpB,MAAM,aAAa,CAAC,eAAe,EAAE,CAAC;QAEtC,uBAAuB;QACvB,MAAM,UAAU,GAAG,MAAM,IAAA,2BAAa,EAAC,aAAa,CAAC,CAAC;QAEtD,qCAAqC;QACrC,MAAM,aAAa,CAAC,aAAa,CAAC;YAChC,SAAS;YACT,UAAU;SACX,CAAC,CAAC;QAEH,MAAM,aAAa,CAAC,cAAc,EAAE,CAAC;IACvC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAA,oBAAK,EAAC,OAAO,EAAE,0BAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAC1C,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "zephyr-cli",
+  "version": "0.1.0",
+  "description": "CLI tool for running build commands and uploading assets to Zephyr",
+  "keywords": [
+    "zephyr",
+    "cli",
+    "deploy",
+    "build",
+    "runner"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ZephyrCloudIO/zephyr-packages.git",
+    "directory": "libs/zephyr-cli"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "ZephyrCloudIO",
+    "url": "https://github.com/ZephyrCloudIO"
+  },
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "ze-cli": "dist/index.js"
+  },
+  "scripts": {
+    "build": "nx run zephyr-cli:build",
+    "patch-version": "pnpm version"
+  },
+  "dependencies": {
+    "cosmiconfig": "^9.0.0",
+    "jsonc-parser": "^3.3.1",
+    "tslib": "catalog:typescript",
+    "zephyr-agent": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/jest": "catalog:typescript",
+    "@types/node": "catalog:typescript",
+    "@typescript-eslint/eslint-plugin": "catalog:eslint",
+    "ts-jest": "catalog:typescript"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/dist/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"version":"5.9.3"}

package/jest.config.ts

@@ -0,0 +1,10 @@
+export default {
+  displayName: 'zephyr-cli',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/libs/zephyr-cli',
+};

package/package.json

@@ -1,31 +1,48 @@
 {
   "name": "zephyr-cli",
-  "version": "0.0.3",
-  "description": "CLI utility for Zephyr projects",
-  "main": "dist/index.js",
-  "bin": {
-    "zephyr": "dist/index.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "prepare": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
+  "version": "0.1.3-next.6",
+  "description": "CLI tool for running build commands and uploading assets to Zephyr",
   "keywords": [
-    "cli",
     "zephyr",
-    "tool"
-  ],
-  "author": "Zephyr Team",
-  "license": "MIT",
-  "files": [
-    "dist"
+    "cli",
+    "deploy",
+    "build",
+    "runner"
   ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ZephyrCloudIO/zephyr-packages.git",
+    "directory": "libs/zephyr-cli"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "ZephyrCloudIO",
+    "url": "https://github.com/ZephyrCloudIO"
+  },
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "ze-cli": "dist/index.js"
+  },
   "dependencies": {
-    "chalk": "^4.1.2"
+    "cosmiconfig": "^9.0.0",
+    "jsonc-parser": "^3.3.1",
+    "tslib": "^2.8.1",
+    "zephyr-agent": "0.1.3-next.6"
   },
   "devDependencies": {
-    "@types/node": "^16.11.12",
-    "typescript": "^4.5.4"
+    "@types/jest": "29.5.14",
+    "@types/node": "^22.13.11",
+    "@typescript-eslint/eslint-plugin": "^8.27.0",
+    "ts-jest": "^29.2.6"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "nx run zephyr-cli:build",
+    "patch-version": "pnpm version"
   }
 }

package/project.json

@@ -0,0 +1,34 @@
+{
+  "name": "zephyr-cli",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/zephyr-cli/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "rootDir": "libs/zephyr-cli/src",
+        "outputPath": "libs/zephyr-cli/dist",
+        "tsConfig": "libs/zephyr-cli/tsconfig.lib.json",
+        "main": "libs/zephyr-cli/src/index.ts"
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist\\{projectRoot}"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
+      "options": {
+        "jestConfig": "libs/zephyr-cli/jest.config.ts"
+      }
+    }
+  }
+}

package/src/cli.ts

@@ -0,0 +1,150 @@
+export interface CliOptions {
+  command: 'run' | 'deploy';
+  commandLine?: string; // For 'run' command
+  directory?: string; // For 'deploy' command
+  target?: 'web' | 'ios' | 'android';
+  verbose?: boolean;
+  ssr?: boolean;
+}
+
+/**
+ * Parse command line arguments.
+ *
+ * Syntax:
+ *
+ * - Ze-cli [options] <command> [args...] - run command (default)
+ * - Ze-cli deploy <directory> [options] - deploy command
+ *
+ * Examples:
+ *
+ * - Ze-cli --ssr pnpm build
+ * - Ze-cli tsc
+ * - Ze-cli NODE_ENV=production webpack
+ * - Ze-cli deploy ./dist
+ * - Ze-cli deploy ./dist --ssr
+ */
+export function parseArgs(args: string[]): CliOptions {
+  const options: CliOptions = {
+    command: 'run', // Default to 'run'
+  };
+
+  // Find where flags end and the command/subcommand begins
+  let commandStartIndex = -1;
+  const flags: string[] = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--help' || arg === '-h') {
+      printHelp();
+      process.exit(0);
+    } else if (arg === '--version' || arg === '-v') {
+      // Version is handled by the caller
+      options.verbose = true;
+    } else if (arg === '--ssr') {
+      options.ssr = true;
+      flags.push(arg);
+    } else if (arg === '--target' || arg === '-t') {
+      const value = args[++i];
+      if (value && ['web', 'ios', 'android'].includes(value)) {
+        options.target = value as 'web' | 'ios' | 'android';
+      }
+      flags.push(arg, value);
+    } else if (arg === '--verbose') {
+      options.verbose = true;
+      flags.push(arg);
+    } else if (!arg.startsWith('-')) {
+      // First non-flag argument
+      commandStartIndex = i;
+      break;
+    }
+  }
+
+  if (commandStartIndex === -1) {
+    printHelp();
+    process.exit(1);
+  }
+
+  const firstArg = args[commandStartIndex];
+
+  // Check if it's a subcommand
+  if (firstArg === 'deploy') {
+    options.command = 'deploy';
+    const directory = args[commandStartIndex + 1];
+
+    if (!directory) {
+      console.error('Error: deploy command requires a directory argument');
+      console.error('Usage: ze-cli deploy <directory> [options]');
+      process.exit(1);
+    }
+
+    options.directory = directory;
+
+    // Parse any additional flags after the directory
+    for (let i = commandStartIndex + 2; i < args.length; i++) {
+      const arg = args[i];
+
+      if (arg === '--ssr') {
+        options.ssr = true;
+      } else if (arg === '--target' || arg === '-t') {
+        const value = args[++i];
+        if (value && ['web', 'ios', 'android'].includes(value)) {
+          options.target = value as 'web' | 'ios' | 'android';
+        }
+      } else if (arg === '--verbose') {
+        options.verbose = true;
+      }
+    }
+  } else {
+    // It's a run command - everything from commandStartIndex onwards is the command
+    options.command = 'run';
+    options.commandLine = args.slice(commandStartIndex).join(' ');
+  }
+
+  return options;
+}
+
+function printHelp(): void {
+  console.log(`
+Usage: ze-cli [options] <command> [args...]
+       ze-cli deploy <directory> [options]
+
+Run a build command and automatically upload assets to Zephyr, or deploy
+pre-built assets from a directory.
+
+Commands:
+  <command> [args...]      Run a build command and upload (default)
+  deploy <directory>       Upload pre-built assets from a directory
+
+Options:
+  --ssr                    Mark this snapshot as server-side rendered
+  --target, -t <target>    Build target: web, ios, or android (default: web)
+  --verbose                Enable verbose output
+  --help, -h               Show this help message
+
+Examples:
+  # Run build commands
+  ze-cli pnpm build
+  ze-cli yarn build
+  ze-cli tsc
+  ze-cli NODE_ENV=production webpack
+  ze-cli --ssr pnpm build
+
+  # Deploy pre-built assets
+  ze-cli deploy ./dist
+  ze-cli deploy ./dist --ssr
+  ze-cli deploy ./build --target ios
+
+How it works:
+  - For run commands, ze-cli executes your build command and automatically
+    detects the output directory to upload assets.
+  - For deploy commands, ze-cli uploads assets from the specified directory.
+  - All stdout/stderr from build commands are passed through.
+  - ze-cli logs are written to stderr only.
+
+Note: No configuration file is needed. Zephyr will automatically detect
+application information from your package.json and git repository.
+
+For more information: https://docs.zephyr-cloud.io/cli
+`);
+}

package/src/commands/deploy.ts

@@ -0,0 +1,74 @@
+import { access, constants } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { ZephyrEngine, logFn, ZephyrError, ZeErrors } from 'zephyr-agent';
+import { extractAssetsFromDirectory } from '../lib/extract-assets';
+import { uploadAssets } from '../lib/upload';
+
+export interface DeployOptions {
+  directory: string;
+  target?: 'web' | 'ios' | 'android';
+  verbose?: boolean;
+  ssr?: boolean;
+  cwd: string;
+}
+
+/**
+ * Deploy command: Upload pre-built assets from a directory to Zephyr. This is similar to
+ * the standalone zephyr-cli tool.
+ */
+export async function deployCommand(options: DeployOptions): Promise<void> {
+  const { directory, target, verbose, ssr, cwd } = options;
+
+  // Resolve the directory path
+  const directoryPath = resolve(cwd, directory);
+
+  // Check if directory exists
+  try {
+    await access(directoryPath, constants.F_OK);
+  } catch {
+    throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+      message: `Directory does not exist: ${directoryPath}`,
+    });
+  }
+
+  if (verbose) {
+    logFn('info', `Uploading assets from: ${directoryPath}`);
+  }
+
+  // Initialize ZephyrEngine with project root context
+  const zephyr_engine = await ZephyrEngine.create({
+    builder: 'unknown',
+    context: cwd,
+  });
+
+  // Set build target if specified
+  if (target) {
+    zephyr_engine.env.target = target;
+  }
+
+  // Set SSR flag if specified
+  if (ssr) {
+    zephyr_engine.env.ssr = true;
+  }
+
+  // Extract assets from the directory
+  if (verbose) {
+    logFn('info', 'Extracting assets from directory...');
+  }
+  const assetsMap = await extractAssetsFromDirectory(directoryPath);
+
+  if (verbose) {
+    const assetCount = Object.keys(assetsMap).length;
+    logFn('info', `Found ${assetCount} assets to upload`);
+  }
+
+  // Upload assets
+  await uploadAssets({
+    zephyr_engine,
+    assetsMap,
+  });
+
+  if (verbose) {
+    logFn('info', 'Upload completed successfully');
+  }
+}

package/src/commands/run.ts

@@ -0,0 +1,196 @@
+import { existsSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+import { ZeErrors, ZephyrEngine, ZephyrError } from 'zephyr-agent';
+import { detectMultipleCommands } from '../lib/command-detector';
+import { extractAssetsFromDirectory } from '../lib/extract-assets';
+import { parseShellCommand, splitCommands } from '../lib/shell-parser';
+import { executeCommand } from '../lib/spawn-helper';
+import { uploadAssets } from '../lib/upload';
+
+export interface RunOptions {
+  commandLine: string;
+  target?: 'web' | 'ios' | 'android';
+  verbose?: boolean;
+  ssr?: boolean;
+  cwd: string;
+}
+
+/** Run command: Execute a build command and automatically upload the resulting assets. */
+export async function runCommand(options: RunOptions): Promise<void> {
+  const { commandLine, target, verbose, ssr, cwd } = options;
+
+  // Log to stderr so it doesn't interfere with command output
+  const log = (level: 'info' | 'warn' | 'error', message: string) => {
+    if (level === 'info' && !verbose) {
+      return;
+    }
+    // All ze-cli logs go to stderr
+    console.error(`[ze-cli] ${message}`);
+  };
+
+  // Parse the shell command - check if there are multiple commands
+  log('info', `Parsing command: ${commandLine}`);
+  const individualCommands = splitCommands(commandLine);
+
+  if (individualCommands.length > 1) {
+    log('info', `Detected ${individualCommands.length} commands to execute`);
+  }
+
+  // Detect multiple commands and their output directories
+  const multiDetection = await detectMultipleCommands(commandLine, cwd);
+  const { commands: detectedCommands, outputDirs, commonOutputDir } = multiDetection;
+
+  // Log detected tools
+  // Flatten commands if there are sub-commands
+  const allCommands: typeof detectedCommands = [];
+  for (const detected of detectedCommands) {
+    if (detected.subCommands && detected.subCommands.length > 0) {
+      // If there are sub-commands, log them instead of the parent
+      allCommands.push(...detected.subCommands);
+    } else {
+      allCommands.push(detected);
+    }
+  }
+
+  for (let i = 0; i < allCommands.length; i++) {
+    const detected = allCommands[i];
+    log('info', `Command ${i + 1}: ${detected.tool}`);
+
+    if (detected.configFile) {
+      log('info', `  Config file: ${detected.configFile}`);
+    }
+
+    if (detected.outputDir) {
+      const absoluteOutputDir = resolve(cwd, detected.outputDir);
+      log('info', `  Output directory: ${relative(cwd, absoluteOutputDir) || '.'}`);
+    }
+  }
+
+  // If multiple output directories detected, show common ancestor
+  if (outputDirs.length > 1 && commonOutputDir) {
+    log(
+      'info',
+      `Multiple output directories detected, using common ancestor: ${relative(cwd, commonOutputDir) || '.'}`
+    );
+  }
+
+  // Warn about dynamic configs
+  if (!outputDirs.length) {
+    console.error('[ze-cli] WARNING: Configuration is too dynamic to analyze!');
+    console.error('[ze-cli] ');
+    console.error(
+      '[ze-cli] Your build tool uses a JavaScript configuration file that cannot be'
+    );
+    console.error('[ze-cli] statically analyzed. This means ze-cli cannot automatically');
+    console.error('[ze-cli] detect the output directory.');
+    console.error('[ze-cli] ');
+    console.error('[ze-cli] Recommendations:');
+    console.error('[ze-cli] 1. Use a Zephyr bundler plugin:');
+    console.error('[ze-cli]    - @zephyrcloud/webpack-plugin');
+    console.error('[ze-cli]    - @zephyrcloud/rollup-plugin');
+    console.error('[ze-cli]    - @zephyrcloud/vite-plugin');
+    console.error('[ze-cli]    - etc.');
+    console.error('[ze-cli] 2. Or use "ze-cli deploy <dir>" after building');
+    console.error('[ze-cli] ');
+    console.error('[ze-cli] For more info: https://docs.zephyr-cloud.io/integrations');
+    console.error('[ze-cli] ');
+  }
+
+  // Display warnings from all commands
+  for (const detected of detectedCommands) {
+    if (detected.warnings.length > 0 && !detected.isDynamicConfig) {
+      for (const warning of detected.warnings) {
+        console.error(`[ze-cli] Warning: ${warning}`);
+      }
+    }
+  }
+
+  // Execute all build commands sequentially
+  for (let i = 0; i < individualCommands.length; i++) {
+    const cmd = individualCommands[i];
+    log('info', `Executing command ${i + 1}/${individualCommands.length}: ${cmd}`);
+
+    try {
+      const parsed = parseShellCommand(cmd);
+      const result = await executeCommand(parsed, cwd);
+
+      if (result.exitCode !== 0) {
+        throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+          message: `Build command failed with exit code ${result.exitCode}`,
+        });
+      }
+
+      log('info', `Command ${i + 1} completed successfully`);
+    } catch (error) {
+      throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+        message: `Failed to execute command: ${cmd}\n${(error as Error).message}`,
+      });
+    }
+  }
+
+  log('info', 'All build commands completed successfully');
+
+  // Determine which output directory to use
+  let outputDir: string | null = null;
+
+  if (commonOutputDir) {
+    outputDir = commonOutputDir;
+  } else if (detectedCommands.length === 1 && detectedCommands[0].outputDir) {
+    outputDir = resolve(cwd, detectedCommands[0].outputDir);
+  }
+
+  // If we couldn't detect the output directory, stop here
+  if (!outputDir) {
+    console.error('[ze-cli] ');
+    console.error('[ze-cli] Could not detect output directory. Skipping upload.');
+    console.error('[ze-cli] Please use "ze-cli deploy <dir>" to upload manually.');
+    console.error('[ze-cli] ');
+    return;
+  }
+
+  log('info', `Using output directory: ${relative(cwd, outputDir) || '.'}`);
+
+  // Check if output directory exists
+  if (!existsSync(outputDir)) {
+    throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+      message: `Output directory does not exist: ${outputDir}`,
+    });
+  }
+
+  // Determine the primary build tool for ZephyrEngine
+  const primaryTool = detectedCommands[0]?.tool || 'unknown';
+
+  // Initialize ZephyrEngine with project root context
+  log('info', 'Initializing Zephyr Engine...');
+  const zephyr_engine = await ZephyrEngine.create({
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    builder: primaryTool as any,
+    context: cwd,
+  });
+
+  // Set build target if specified
+  if (target) {
+    zephyr_engine.env.target = target;
+  }
+
+  // Set SSR flag if specified
+  if (ssr) {
+    zephyr_engine.env.ssr = true;
+  }
+
+  // Extract assets from the output directory
+  log('info', 'Extracting assets from output directory...');
+  const assetsMap = await extractAssetsFromDirectory(outputDir);
+
+  const assetCount = Object.keys(assetsMap).length;
+  log('info', `Found ${assetCount} assets to upload`);
+
+  // Upload assets
+  log('info', 'Uploading assets to Zephyr...');
+  await uploadAssets({
+    zephyr_engine,
+    assetsMap,
+  });
+
+  log('info', 'Upload completed successfully');
+}