zephyr-cli 0.0.2 → 0.1.0

package/src/lib/config-readers.ts

@@ -0,0 +1,269 @@
+import { cosmiconfig } from 'cosmiconfig';
+import { parse as parseJsonc } from 'jsonc-parser';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface PackageJsonConfig {
+  scripts?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+export interface TsConfigJson {
+  compilerOptions?: {
+    outDir?: string;
+    rootDir?: string;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+/** Read and parse package.json from the given directory */
+export function readPackageJson(cwd: string): PackageJsonConfig | null {
+  const packageJsonPath = join(cwd, 'package.json');
+
+  if (!existsSync(packageJsonPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(packageJsonPath, 'utf-8');
+    return parseJsonc(content);
+  } catch {
+    return null;
+  }
+}
+
+/** Read and parse tsconfig.json from the given directory */
+export function readTsConfig(
+  cwd: string,
+  configPath = 'tsconfig.json'
+): TsConfigJson | null {
+  const tsConfigPath = join(cwd, configPath);
+
+  if (!existsSync(tsConfigPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(tsConfigPath, 'utf-8');
+    // Parse JSON with comments support using jsonc-parser
+    return parseJsonc(content);
+  } catch (error) {
+    console.error(`Error reading tsconfig.json: ${error}`);
+    return null;
+  }
+}
+
+/** Check if a file exists and has a .js or .mjs extension */
+export function isJavaScriptConfig(cwd: string, baseName: string): boolean {
+  const jsExtensions = ['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts'];
+
+  for (const ext of jsExtensions) {
+    const configPath = join(cwd, `${baseName}${ext}`);
+    if (existsSync(configPath)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/** Check if a configuration file exists (any extension) */
+export function configFileExists(cwd: string, baseName: string): string | null {
+  const extensions = ['.json', '.js', '.mjs', '.cjs', '.ts'];
+
+  for (const ext of extensions) {
+    const configPath = join(cwd, `${baseName}${ext}`);
+    if (existsSync(configPath)) {
+      return configPath;
+    }
+  }
+
+  return null;
+}
+
+/** Generic interface for framework configuration with output directory */
+export interface FrameworkConfig {
+  /** The detected output directory from the config */
+  outputDir?: string | null;
+  /** The full configuration object (framework-specific) */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  config: any;
+  /** The file path where the config was loaded from */
+  filepath: string;
+}
+
+/** Load Webpack configuration using cosmiconfig */
+export async function loadWebpackConfig(cwd: string): Promise<FrameworkConfig | null> {
+  try {
+    const explorer = cosmiconfig('webpack', {
+      searchPlaces: [
+        'webpack.config.js',
+        'webpack.config.mjs',
+        'webpack.config.cjs',
+        'webpack.config.ts',
+      ],
+    });
+
+    const result = await explorer.search(cwd);
+    if (!result || !result.config) {
+      return null;
+    }
+
+    // Extract output.path from webpack config
+    let outputDir: string | null = null;
+    const config = result.config;
+
+    // Handle function configs (they receive env and argv)
+    if (typeof config === 'function') {
+      try {
+        const resolvedConfig = await config({}, { mode: 'production' });
+        outputDir = resolvedConfig?.output?.path || null;
+      } catch {
+        // If function execution fails, we can't extract the output
+        outputDir = null;
+      }
+    } else if (config?.output?.path) {
+      outputDir = config.output.path;
+    }
+
+    return {
+      outputDir,
+      config: result.config,
+      filepath: result.filepath,
+    };
+  } catch {
+    // If loading fails, return null
+    return null;
+  }
+}
+
+/** Load Vite configuration using cosmiconfig */
+export async function loadViteConfig(cwd: string): Promise<FrameworkConfig | null> {
+  try {
+    const explorer = cosmiconfig('vite', {
+      searchPlaces: [
+        'vite.config.js',
+        'vite.config.mjs',
+        'vite.config.cjs',
+        'vite.config.ts',
+      ],
+    });
+
+    const result = await explorer.search(cwd);
+    if (!result || !result.config) {
+      return null;
+    }
+
+    // Extract build.outDir from vite config
+    let outputDir: string | null = null;
+    const config = result.config;
+
+    // Handle function configs (they receive config env)
+    if (typeof config === 'function') {
+      try {
+        const resolvedConfig = await config({ mode: 'production', command: 'build' });
+        outputDir = resolvedConfig?.build?.outDir || 'dist';
+      } catch {
+        outputDir = 'dist'; // Vite default
+      }
+    } else if (config?.build?.outDir) {
+      outputDir = config.build.outDir;
+    } else {
+      outputDir = 'dist'; // Vite default
+    }
+
+    return {
+      outputDir,
+      config: result.config,
+      filepath: result.filepath,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Load Rollup configuration using cosmiconfig */
+export async function loadRollupConfig(cwd: string): Promise<FrameworkConfig | null> {
+  try {
+    const explorer = cosmiconfig('rollup', {
+      searchPlaces: [
+        'rollup.config.js',
+        'rollup.config.mjs',
+        'rollup.config.cjs',
+        'rollup.config.ts',
+      ],
+    });
+
+    const result = await explorer.search(cwd);
+    if (!result || !result.config) {
+      return null;
+    }
+
+    // Extract output.dir or output.file from rollup config
+    let outputDir: string | null = null;
+    const config = result.config;
+
+    // Handle function configs
+    if (typeof config === 'function') {
+      try {
+        const resolvedConfig = await config({});
+        if (Array.isArray(resolvedConfig)) {
+          // Multiple outputs - take the first one
+          outputDir =
+            resolvedConfig[0]?.output?.dir || resolvedConfig[0]?.output?.file || null;
+        } else {
+          outputDir = resolvedConfig?.output?.dir || resolvedConfig?.output?.file || null;
+        }
+      } catch {
+        outputDir = null;
+      }
+    } else if (Array.isArray(config)) {
+      // Multiple outputs - take the first one
+      outputDir = config[0]?.output?.dir || config[0]?.output?.file || null;
+    } else if (config?.output) {
+      const output = Array.isArray(config.output) ? config.output[0] : config.output;
+      outputDir = output?.dir || output?.file || null;
+    }
+
+    // If outputDir is a file path, extract the directory
+    if (outputDir && outputDir.includes('.')) {
+      const lastSlash = Math.max(outputDir.lastIndexOf('/'), outputDir.lastIndexOf('\\'));
+      if (lastSlash !== -1) {
+        outputDir = outputDir.substring(0, lastSlash);
+      }
+    }
+
+    return {
+      outputDir,
+      config: result.config,
+      filepath: result.filepath,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Load SWC configuration using cosmiconfig */
+export async function loadSwcConfig(cwd: string): Promise<FrameworkConfig | null> {
+  try {
+    const explorer = cosmiconfig('swc', {
+      searchPlaces: ['.swcrc', '.swcrc.json', '.swcrc.js', '.swcrc.mjs', '.swcrc.cjs'],
+    });
+
+    const result = await explorer.search(cwd);
+    if (!result || !result.config) {
+      return null;
+    }
+
+    // SWC doesn't have a standard output directory config
+    // Most projects use a custom output directory
+    return {
+      outputDir: null,
+      config: result.config,
+      filepath: result.filepath,
+    };
+  } catch {
+    return null;
+  }
+}

package/src/lib/extract-assets.ts

@@ -0,0 +1,111 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
+import { buildAssetsMap, logFn, type ZeBuildAssetsMap } from 'zephyr-agent';
+
+interface DirectoryAsset {
+  content: Buffer | string;
+  type: string;
+}
+
+function extractBuffer(asset: DirectoryAsset): Buffer | string | undefined {
+  return asset.content;
+}
+
+function getAssetType(asset: DirectoryAsset): string {
+  return asset.type;
+}
+
+/** Normalize path separators to forward slashes for cross-platform consistency */
+function normalizePath(filePath: string): string {
+  return filePath.split(sep).join('/');
+}
+
+/**
+ * Extract assets map from a directory by recursively walking through it. Similar to
+ * extractAstroAssetsMap but for any directory.
+ */
+export async function extractAssetsFromDirectory(
+  buildDir: string
+): Promise<ZeBuildAssetsMap> {
+  const assets: Record<string, DirectoryAsset> = {};
+
+  // Recursively walk through the build directory
+  async function walkDir(dirPath: string): Promise<void> {
+    try {
+      const entries = await readdir(dirPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = join(dirPath, entry.name);
+
+        if (entry.isDirectory()) {
+          await walkDir(fullPath);
+        } else if (entry.isFile()) {
+          // Get relative path from build directory
+          const relativePath = normalizePath(relative(buildDir, fullPath));
+
+          // Skip certain files that shouldn't be uploaded
+          if (shouldSkipFile(relativePath)) {
+            continue;
+          }
+
+          try {
+            const content = await readFile(fullPath);
+            const fileType = getFileType(relativePath);
+
+            assets[relativePath] = {
+              content,
+              type: fileType,
+            };
+          } catch (readError) {
+            logFn('warn', `Failed to read file ${fullPath}: ${readError}`);
+          }
+        }
+      }
+    } catch (error) {
+      logFn('warn', `Failed to walk directory ${dirPath}: ${error}`);
+    }
+  }
+
+  await walkDir(buildDir);
+
+  return buildAssetsMap(assets, extractBuffer, getAssetType);
+}
+
+function shouldSkipFile(filePath: string): boolean {
+  // Skip common files that shouldn't be uploaded
+  const skipPatterns = [
+    /\.map$/, // Source maps
+    /node_modules/, // Node modules
+    /\.git/, // Git files
+    /\.DS_Store$/, // macOS files
+    /thumbs\.db$/i, // Windows files
+  ];
+
+  return skipPatterns.some((pattern) => pattern.test(filePath));
+}
+
+function getFileType(filePath: string): string {
+  const extension = filePath.split('.').pop()?.toLowerCase() || '';
+
+  const typeMap: Record<string, string> = {
+    html: 'text/html',
+    css: 'text/css',
+    js: 'application/javascript',
+    mjs: 'application/javascript',
+    json: 'application/json',
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    svg: 'image/svg+xml',
+    ico: 'image/x-icon',
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    ttf: 'font/ttf',
+    eot: 'application/vnd.ms-fontobject',
+    xml: 'text/xml',
+    txt: 'text/plain',
+  };
+
+  return typeMap[extension] || 'application/octet-stream';
+}

package/src/lib/shell-parser.ts

@@ -0,0 +1,229 @@
+import { ZeErrors, ZephyrError } from 'zephyr-agent';
+
+export interface ParsedCommand {
+  /** The main command to execute (without environment variables) */
+  command: string;
+  /** Environment variables set for this command */
+  envVars: Record<string, string>;
+  /** Arguments passed to the command */
+  args: string[];
+  /** The full command line as a string */
+  fullCommand: string;
+}
+
+/**
+ * Parse a shell command to extract the actual command, args, and environment variables.
+ * Uses simple regex-based parsing to handle common cases like:
+ *
+ * - `pnpm build`
+ * - `NODE_ENV=production webpack --mode production`
+ * - `KEY1=value1 KEY2=value2 command arg1 arg2`
+ *
+ * @example
+ *   parseShellCommand('NODE_ENV=production webpack --mode production');
+ *   // Returns: { command: 'webpack', envVars: { NODE_ENV: 'production' }, args: ['--mode', 'production'] }
+ *
+ * @example
+ *   parseShellCommand('pnpm build');
+ *   // Returns: { command: 'pnpm', envVars: {}, args: ['build'] }
+ */
+export function parseShellCommand(commandLine: string): ParsedCommand {
+  const envVars: Record<string, string> = {};
+  const trimmed = commandLine.trim();
+
+  if (!trimmed) {
+    throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+      message: 'Empty command line',
+    });
+  }
+
+  // Split by whitespace while respecting quotes
+  const tokens = tokenizeCommand(trimmed);
+
+  if (tokens.length === 0) {
+    throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+      message: `Failed to parse command: ${commandLine}`,
+    });
+  }
+
+  let i = 0;
+
+  // Extract environment variables (KEY=VALUE format at the beginning)
+  while (i < tokens.length) {
+    const token = tokens[i];
+    const match = token.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+
+    if (match) {
+      const [, name, value] = match;
+      envVars[name] = value;
+      i++;
+    } else {
+      break;
+    }
+  }
+
+  // The next token should be the command
+  if (i >= tokens.length) {
+    throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+      message: `Failed to parse command: ${commandLine}\nNo command found after environment variables`,
+    });
+  }
+
+  const command = tokens[i];
+  i++;
+
+  // Remaining tokens are arguments
+  const args = tokens.slice(i);
+
+  return {
+    command,
+    envVars,
+    args,
+    fullCommand: commandLine,
+  };
+}
+
+/**
+ * Split a command line into multiple commands based on shell operators (;, &&) Respects
+ * quotes and escapes.
+ *
+ * @example
+ *   splitCommands('npm run build && npm run test');
+ *   // Returns: ['npm run build', 'npm run test']
+ *
+ * @example
+ *   splitCommands('echo "hello; world" && npm run build');
+ *   // Returns: ['echo "hello; world"', 'npm run build']
+ */
+export function splitCommands(commandLine: string): string[] {
+  const commands: string[] = [];
+  let current = '';
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escaped = false;
+
+  for (let i = 0; i < commandLine.length; i++) {
+    const char = commandLine[i];
+    const nextChar = i + 1 < commandLine.length ? commandLine[i + 1] : '';
+
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+
+    if (char === '\\') {
+      current += char;
+      escaped = true;
+      continue;
+    }
+
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      current += char;
+      continue;
+    }
+
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      current += char;
+      continue;
+    }
+
+    // Check for shell operators outside quotes
+    if (!inSingleQuote && !inDoubleQuote) {
+      // Check for &&
+      if (char === '&' && nextChar === '&') {
+        const trimmed = current.trim();
+        if (trimmed) {
+          commands.push(trimmed);
+        }
+        current = '';
+        i++; // Skip the next &
+        continue;
+      }
+
+      // Check for ;
+      if (char === ';') {
+        const trimmed = current.trim();
+        if (trimmed) {
+          commands.push(trimmed);
+        }
+        current = '';
+        continue;
+      }
+    }
+
+    current += char;
+  }
+
+  // Add the last command if any
+  const trimmed = current.trim();
+  if (trimmed) {
+    commands.push(trimmed);
+  }
+
+  if (inSingleQuote || inDoubleQuote) {
+    throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+      message: 'Unmatched quote in command line',
+    });
+  }
+
+  return commands;
+}
+
+/** Tokenize a command line string, respecting quotes and escapes */
+function tokenizeCommand(commandLine: string): string[] {
+  const tokens: string[] = [];
+  let current = '';
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escaped = false;
+
+  for (let i = 0; i < commandLine.length; i++) {
+    const char = commandLine[i];
+
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+
+    if (char === '\\') {
+      escaped = true;
+      continue;
+    }
+
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      continue;
+    }
+
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      continue;
+    }
+
+    if (/\s/.test(char) && !inSingleQuote && !inDoubleQuote) {
+      if (current) {
+        tokens.push(current);
+        current = '';
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (current) {
+    tokens.push(current);
+  }
+
+  if (inSingleQuote || inDoubleQuote) {
+    throw new ZephyrError(ZeErrors.ERR_UNKNOWN, {
+      message: 'Unmatched quote in command line',
+    });
+  }
+
+  return tokens;
+}

package/src/lib/spawn-helper.ts

@@ -0,0 +1,49 @@
+import { spawn } from 'node:child_process';
+import type { ParsedCommand } from './shell-parser';
+
+export interface SpawnResult {
+  exitCode: number;
+  signal: NodeJS.Signals | null;
+}
+
+/**
+ * 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
+ */
+export async function executeCommand(
+  parsed: ParsedCommand,
+  cwd: string
+): Promise<SpawnResult> {
+  return new Promise((resolve, reject) => {
+    const { command, args, envVars } = parsed;
+
+    // Merge environment variables
+    const env = {
+      ...process.env,
+      ...envVars,
+    };
+
+    // Spawn the command
+    const child = 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 ?? 1,
+        signal,
+      });
+    });
+  });
+}

package/src/lib/upload.ts

@@ -0,0 +1,39 @@
+import type { ZeBuildAssetsMap } from 'zephyr-edge-contract';
+import type { ZephyrEngine } from 'zephyr-agent';
+import { logFn, ZephyrError } from 'zephyr-agent';
+import { getBuildStats } from './build-stats';
+
+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 async function uploadAssets(options: UploadOptions): Promise<void> {
+  const { zephyr_engine, assetsMap } = options;
+
+  try {
+    // Start a new build
+    await zephyr_engine.start_new_build();
+
+    // Generate build stats
+    const buildStats = await getBuildStats(zephyr_engine);
+
+    // Upload assets and finish the build
+    await zephyr_engine.upload_assets({
+      assetsMap,
+      buildStats,
+    });
+
+    await zephyr_engine.build_finished();
+  } catch (error) {
+    logFn('error', ZephyrError.format(error));
+    throw error;
+  }
+}