@vue-skuilder/cli 0.1.7 → 0.1.8-0

package/src/commands/unpack.ts

@@ -31,7 +31,7 @@ interface UnpackOptions {
   cleanupOnError: boolean;
 }
 
-async function unpackCourse(coursePath: string, options: UnpackOptions) {
+export async function unpackCourse(coursePath: string, options: UnpackOptions) {
   // Store original ENV values for cleanup
   const originalEnv = {
     COUCHDB_SERVER_PROTOCOL: ENV.COUCHDB_SERVER_PROTOCOL,

package/src/types.ts

@@ -4,6 +4,11 @@ export interface CliOptions {
   interactive: boolean;
   couchdbUrl?: string;
   courseId?: string;
+  importCourseData?: boolean;
+  importServerUrl?: string;
+  importUsername?: string;
+  importPassword?: string;
+  importCourseIds?: string;
 }
 
 export interface ProjectConfig {

package/src/utils/ExpressManager.ts

@@ -0,0 +1,210 @@
+import { spawn, ChildProcess } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import fs from 'fs';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export interface ExpressManagerOptions {
+  port: number;
+  couchdbUrl: string;
+  couchdbUsername: string;
+  couchdbPassword: string;
+  projectPath?: string; // Path to the project for studio mode
+}
+
+export interface ExpressManagerCallbacks {
+  onLog?: (message: string) => void;
+  onError?: (error: string) => void;
+}
+
+export class ExpressManager {
+  private process: ChildProcess | null = null;
+  private readonly options: ExpressManagerOptions;
+  private readonly callbacks: ExpressManagerCallbacks;
+
+  constructor(options: ExpressManagerOptions, callbacks: ExpressManagerCallbacks = {}) {
+    this.options = options;
+    this.callbacks = callbacks;
+  }
+
+  async start(): Promise<void> {
+    if (this.process) {
+      throw new Error('Express server is already running');
+    }
+
+    const expressAssetsPath = join(__dirname, '..', 'express-assets');
+
+    if (!fs.existsSync(expressAssetsPath)) {
+      throw new Error('Express assets not found. Please rebuild the CLI package.');
+    }
+
+    const expressMainPath = join(expressAssetsPath, 'app.js');
+
+    if (!fs.existsSync(expressMainPath)) {
+      throw new Error('Express main file not found at: ' + expressMainPath);
+    }
+
+    // Find available port starting from requested port
+    const availablePort = await this.findAvailablePort(this.options.port);
+
+    // Get version from package.json
+    let version = '0.0.0';
+    try {
+      const packageJsonPath = join(__dirname, '..', '..', 'package.json');
+      const packageJson = require(packageJsonPath);
+      version = packageJson.version || '0.0.0';
+    } catch (error) {
+      console.warn('Could not read package.json for version:', error);
+      // Fallback version if package.json not found
+      version = '0.0.0';
+    }
+
+    // Set environment variables for express
+    const env = {
+      ...process.env,
+      PORT: availablePort.toString(),
+      COUCHDB_SERVER: this.extractServerFromUrl(this.options.couchdbUrl),
+      COUCHDB_PROTOCOL: this.extractProtocolFromUrl(this.options.couchdbUrl),
+      COUCHDB_ADMIN: this.options.couchdbUsername,
+      COUCHDB_PASSWORD: this.options.couchdbPassword,
+      VERSION: version,
+      NODE_ENV: 'studio',
+      PROJECT_PATH: this.options.projectPath || process.cwd(),
+    };
+
+    return new Promise((resolve, reject) => {
+      this.process = spawn('node', [expressMainPath], {
+        env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd: expressAssetsPath,
+      });
+
+      if (!this.process) {
+        reject(new Error('Failed to start Express process'));
+        return;
+      }
+
+      let started = false;
+
+      // Handle stdout
+      this.process.stdout?.on('data', (data: Buffer) => {
+        const message = data.toString().trim();
+        if (message.includes('listening on port') && !started) {
+          started = true;
+          this.options.port = availablePort; // Update with actual port
+          resolve();
+        }
+        this.callbacks.onLog?.(message);
+      });
+
+      // Handle stderr
+      this.process.stderr?.on('data', (data: Buffer) => {
+        const error = data.toString().trim();
+        this.callbacks.onError?.(error);
+      });
+
+      // Handle process exit
+      this.process.on('exit', (code) => {
+        this.process = null;
+        if (code !== 0 && code !== null) {
+          this.callbacks.onError?.(`Express process exited with code ${code}`);
+        }
+      });
+
+      // Handle process errors
+      this.process.on('error', (error) => {
+        this.process = null;
+        if (!started) {
+          reject(error);
+        } else {
+          this.callbacks.onError?.(`Express process error: ${error.message}`);
+        }
+      });
+
+      // Timeout if server doesn't start within 10 seconds
+      setTimeout(() => {
+        if (!started) {
+          void this.stop();
+          reject(new Error('Express server failed to start within timeout'));
+        }
+      }, 10000);
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (!this.process) {
+      return;
+    }
+
+    return new Promise((resolve) => {
+      if (!this.process) {
+        resolve();
+        return;
+      }
+
+      this.process.on('exit', () => {
+        this.process = null;
+        resolve();
+      });
+
+      // Try graceful shutdown first
+      this.process.kill('SIGTERM');
+
+      // Force kill after 5 seconds if still running
+      setTimeout(() => {
+        if (this.process) {
+          this.process.kill('SIGKILL');
+          this.process = null;
+          resolve();
+        }
+      }, 5000);
+    });
+  }
+
+  getConnectionDetails() {
+    return {
+      url: `http://localhost:${this.options.port}`,
+      port: this.options.port,
+    };
+  }
+
+  private async findAvailablePort(startPort: number): Promise<number> {
+    const net = await import('net');
+
+    for (let port = startPort; port < startPort + 100; port++) {
+      if (await this.isPortAvailable(port, net)) {
+        return port;
+      }
+    }
+
+    throw new Error(`No available port found starting from ${startPort}`);
+  }
+
+  private isPortAvailable(port: number, net: typeof import('net')): Promise<boolean> {
+    return new Promise((resolve) => {
+      const server = net.createServer();
+
+      server.listen(port, '127.0.0.1', () => {
+        server.close(() => resolve(true));
+      });
+
+      server.on('error', () => resolve(false));
+    });
+  }
+
+  private extractServerFromUrl(url: string): string {
+    // Extract hostname:port from URL like "http://localhost:5984"
+    const match = url.match(/https?:\/\/([^/]+)/);
+    return match ? match[1] : 'localhost:5984';
+  }
+
+  private extractProtocolFromUrl(url: string): string {
+    // Extract protocol from URL like "http://localhost:5984"
+    return url.startsWith('https') ? 'https' : 'http';
+  }
+}

package/src/utils/NodeFileSystemAdapter.ts

@@ -1,6 +1,7 @@
 // packages/cli/src/utils/NodeFileSystemAdapter.ts
 
 import fs from 'fs';
+import fse from 'fs-extra';
 import path from 'path';
 import { FileSystemAdapter, FileStats, FileSystemError } from '@vue-skuilder/db';
 
@@ -50,7 +51,7 @@ export class NodeFileSystemAdapter implements FileSystemAdapter {
       return {
         isDirectory: () => stats.isDirectory(),
         isFile: () => stats.isFile(),
-        size: stats.size
+        size: stats.size,
       };
     } catch (error) {
       throw new FileSystemError(
@@ -62,11 +63,54 @@ export class NodeFileSystemAdapter implements FileSystemAdapter {
     }
   }
 
+  async writeFile(filePath: string, data: string | Buffer): Promise<void> {
+    try {
+      await fse.writeFile(filePath, data);
+    } catch (error) {
+      throw new FileSystemError(
+        `Failed to write file: ${error instanceof Error ? error.message : String(error)}`,
+        'writeFile',
+        filePath,
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  async writeJson(filePath: string, data: unknown, options?: { spaces?: number }): Promise<void> {
+    try {
+      await fse.writeJson(filePath, data, options);
+    } catch (error) {
+      throw new FileSystemError(
+        `Failed to write JSON file: ${error instanceof Error ? error.message : String(error)}`,
+        'writeJson',
+        filePath,
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
+  async ensureDir(dirPath: string): Promise<void> {
+    try {
+      await fse.ensureDir(dirPath);
+    } catch (error) {
+      throw new FileSystemError(
+        `Failed to ensure directory: ${error instanceof Error ? error.message : String(error)}`,
+        'ensureDir',
+        dirPath,
+        error instanceof Error ? error : undefined
+      );
+    }
+  }
+
   joinPath(...segments: string[]): string {
     return path.join(...segments);
   }
 
+  dirname(filePath: string): string {
+    return path.dirname(filePath);
+  }
+
   isAbsolute(filePath: string): boolean {
     return path.isAbsolute(filePath);
   }
-}
+}

package/src/utils/error-reporting.ts

@@ -0,0 +1,192 @@
+import chalk from 'chalk';
+
+/**
+ * Error categories for studio-ui build failures
+ */
+export enum StudioBuildErrorType {
+  QUESTIONS_HASH_ERROR = 'questions-hash-error',
+  BUILD_FAILURE = 'build-failure', 
+  COPY_FAILURE = 'copy-failure',
+  MISSING_SOURCE = 'missing-source',
+  MISSING_DEPENDENCIES = 'missing-dependencies',
+  VITE_BUILD_ERROR = 'vite-build-error',
+  TYPESCRIPT_ERROR = 'typescript-error',
+  CRITICAL_ERROR = 'critical-error'
+}
+
+/**
+ * Structured error information for studio-ui build failures
+ */
+export interface StudioBuildError {
+  type: StudioBuildErrorType;
+  message: string;
+  cause?: Error;
+  context?: Record<string, unknown>;
+  recoverable: boolean;
+  fallbackAvailable: boolean;
+}
+
+/**
+ * Create a structured studio build error
+ */
+export function createStudioBuildError(
+  type: StudioBuildErrorType,
+  message: string,
+  options: {
+    cause?: Error;
+    context?: Record<string, unknown>;
+    recoverable?: boolean;
+    fallbackAvailable?: boolean;
+  } = {}
+): StudioBuildError {
+  return {
+    type,
+    message,
+    cause: options.cause,
+    context: options.context,
+    recoverable: options.recoverable ?? true,
+    fallbackAvailable: options.fallbackAvailable ?? true
+  };
+}
+
+/**
+ * Report a studio build error with appropriate formatting and guidance
+ */
+export function reportStudioBuildError(error: StudioBuildError): void {
+  // Main error message
+  console.error(chalk.red(`❌ Studio-UI Build Error: ${error.message}`));
+  
+  // Error type context
+  console.error(chalk.gray(`   Type: ${error.type}`));
+  
+  // Underlying cause if available
+  if (error.cause) {
+    console.error(chalk.gray(`   Cause: ${error.cause.message}`));
+  }
+  
+  // Context information
+  if (error.context) {
+    for (const [key, value] of Object.entries(error.context)) {
+      console.error(chalk.gray(`   ${key}: ${String(value)}`));
+    }
+  }
+  
+  // Recovery guidance
+  if (error.recoverable) {
+    if (error.fallbackAvailable) {
+      console.log(chalk.yellow(`   Fallback: Using default studio-ui (without local questions)`));
+    } else {
+      console.log(chalk.yellow(`   Recovery: Manual intervention required`));
+    }
+  } else {
+    console.error(chalk.red(`   Critical: Studio session cannot continue`));
+  }
+  
+  // Type-specific guidance
+  provideBuildErrorGuidance(error.type);
+}
+
+/**
+ * Provide specific guidance based on error type
+ */
+function provideBuildErrorGuidance(errorType: StudioBuildErrorType): void {
+  switch (errorType) {
+    case StudioBuildErrorType.QUESTIONS_HASH_ERROR:
+      console.log(chalk.cyan(`   💡 Check that src/questions/ directory is accessible`));
+      console.log(chalk.cyan(`   💡 Verify file permissions and disk space`));
+      break;
+      
+    case StudioBuildErrorType.BUILD_FAILURE:
+      console.log(chalk.cyan(`   💡 Check that Vite build dependencies are installed`));
+      console.log(chalk.cyan(`   💡 Verify TypeScript configuration is valid`));
+      break;
+      
+    case StudioBuildErrorType.COPY_FAILURE:
+      console.log(chalk.cyan(`   💡 Check write permissions for .skuilder/studio-builds/`));
+      console.log(chalk.cyan(`   💡 Verify sufficient disk space available`));
+      break;
+      
+    case StudioBuildErrorType.MISSING_SOURCE:
+      console.log(chalk.cyan(`   💡 Rebuild CLI package: yarn workspace @vue-skuilder/cli build`));
+      console.log(chalk.cyan(`   💡 Verify studio-ui source was embedded during build`));
+      break;
+      
+    case StudioBuildErrorType.MISSING_DEPENDENCIES:
+      console.log(chalk.cyan(`   💡 Install dependencies: yarn install`));
+      console.log(chalk.cyan(`   💡 Check that required packages are in package.json`));
+      break;
+      
+    case StudioBuildErrorType.VITE_BUILD_ERROR:
+      console.log(chalk.cyan(`   💡 Check question type implementations for syntax errors`));
+      console.log(chalk.cyan(`   💡 Verify all imports and dependencies are available`));
+      break;
+      
+    case StudioBuildErrorType.TYPESCRIPT_ERROR:
+      console.log(chalk.cyan(`   💡 Check TypeScript configuration in tsconfig.json`));
+      console.log(chalk.cyan(`   💡 Verify all question types have proper type definitions`));
+      break;
+      
+    case StudioBuildErrorType.CRITICAL_ERROR:
+      console.log(chalk.cyan(`   💡 Report this issue to the vue-skuilder team`));
+      console.log(chalk.cyan(`   💡 Include the full error output in your report`));
+      break;
+  }
+}
+
+/**
+ * Wrap a studio build operation with error handling
+ */
+export async function withStudioBuildErrorHandling<T>(
+  operation: () => Promise<T>,
+  errorType: StudioBuildErrorType,
+  context?: Record<string, unknown>
+): Promise<T> {
+  try {
+    return await operation();
+  } catch (error) {
+    const buildError = createStudioBuildError(
+      errorType,
+      error instanceof Error ? error.message : String(error),
+      {
+        cause: error instanceof Error ? error : undefined,
+        context,
+        recoverable: true,
+        fallbackAvailable: true
+      }
+    );
+    
+    reportStudioBuildError(buildError);
+    throw buildError;
+  }
+}
+
+/**
+ * Check if error is a recoverable studio build error
+ */
+export function isRecoverableStudioBuildError(error: unknown): boolean {
+  return error instanceof Error && 
+         'type' in error && 
+         'recoverable' in error &&
+         Boolean(error.recoverable);
+}
+
+/**
+ * Extract error details for logging
+ */
+export function extractErrorDetails(error: unknown): {
+  message: string;
+  stack?: string;
+  code?: string;
+} {
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      stack: error.stack,
+      code: 'code' in error ? String(error.code) : undefined
+    };
+  }
+  
+  return {
+    message: String(error)
+  };
+}

package/src/utils/pack-courses.ts

@@ -1,10 +1,6 @@
-import { execFile } from 'child_process';
-import { promisify } from 'util';
 import chalk from 'chalk';
 import path from 'path';
 
-const execFileAsync = promisify(execFile);
-
 export interface PackCoursesOptions {
   server: string;
   username?: string;
@@ -25,44 +21,23 @@ export async function packCourses(options: PackCoursesOptions): Promise<void> {
 
   console.log(chalk.cyan(`\n📦 Packing ${courseIds.length} course(s) to ${outputDir}...`));
 
-  for (const courseId of courseIds) {
-    const args = ['pack', courseId, '--server', server, '--output', outputDir];
-
-    if (username) {
-      args.push('--username', username);
-    }
-
-    if (password) {
-      args.push('--password', password);
-    }
-
-    const cliPath = path.join(process.cwd(), 'dist', 'cli.js');
-    const commandArgs = ['pack', courseId, '--server', server, '--output', outputDir];
-
-    if (username) {
-      commandArgs.push('--username', username);
-    }
-
-    if (password) {
-      commandArgs.push('--password', password);
-    }
+  // Import the pack command function
+  const { packCourse } = await import('../commands/pack.js');
 
+  for (const courseId of courseIds) {
     try {
       console.log(chalk.gray(`🔄 Packing course: ${courseId}`));
 
-      const { stdout, stderr } = await execFileAsync('node', [cliPath, ...commandArgs], {
-        cwd: process.cwd(),
-        maxBuffer: 1024 * 1024 * 10, // 10MB buffer for large outputs
+      // Call the existing pack command directly instead of subprocess
+      await packCourse(courseId, {
+        server,
+        username,
+        password,
+        output: outputDir,
+        chunkSize: '1000',
+        noAttachments: false
       });
 
-      if (stdout) {
-        console.log(stdout);
-      }
-
-      if (stderr) {
-        console.error(chalk.yellow(stderr));
-      }
-
       console.log(chalk.green(`✅ Successfully packed course: ${courseId}`));
     } catch (error: unknown) {
       console.error(chalk.red(`❌ Failed to pack course ${courseId}:`));

package/src/utils/prompts.ts

@@ -389,14 +389,48 @@ export async function gatherProjectConfig(
       couchdbUrl: options.couchdbUrl,
       course: options.courseId,
       theme: PREDEFINED_THEMES[options.theme],
+      // Handle import options for static data layer
+      importCourseData: options.importCourseData,
+      importServerUrl: options.importServerUrl,
+      importUsername: options.importUsername,
+      importPassword: options.importPassword,
     };
 
+    // Parse comma-separated course IDs if provided
+    if (options.importCourseIds) {
+      config.importCourseIds = options.importCourseIds
+        .split(',')
+        .map((id: string) => id.trim())
+        .filter((id: string) => id.length > 0);
+    }
+
     // Validate required fields for non-interactive mode
     if (config.dataLayerType === 'couch' && !config.couchdbUrl) {
       throw new Error(
         'CouchDB URL is required when using dynamic data layer. Use --couchdb-url option.'
       );
     }
+
+    // Validate required fields for static data layer course import
+    if (config.importCourseData) {
+      if (config.dataLayerType !== 'static') {
+        throw new Error(
+          'Course import is only available for static data layer. Use --data-layer static.'
+        );
+      }
+      
+      if (!config.importServerUrl) {
+        throw new Error(
+          'Import server URL is required when importing course data. Use --import-server-url option.'
+        );
+      }
+
+      if (!config.importCourseIds || config.importCourseIds.length === 0) {
+        throw new Error(
+          'Course IDs are required when importing course data. Use --import-course-ids option.'
+        );
+      }
+    }
   }
 
   return config as ProjectConfig;