cloud-ide-cide 2.0.34

package/buildAllProjects.js

@@ -0,0 +1,131 @@
+const { execSync } = require('child_process');
+const { readFileSync, existsSync } = require('fs');
+const path = require('path');
+
+/**
+ * Build all Cloud IDE projects
+ * This function reads package.json scripts and runs all build-<project> commands
+ * excluding the main 'build' command
+ * 
+ * @param {boolean} shouldInstall - Whether to install packages after building
+ */
+async function buildAllProjects(shouldInstall = false) {
+    console.log('🚀 Building all Cloud IDE projects...\n');
+    
+    // Store the original working directory
+    const originalCwd = process.cwd();
+    
+    try {
+        // Read package.json to get all build scripts
+        const packageJsonPath = path.join(originalCwd, 'package.json');
+        
+        if (!existsSync(packageJsonPath)) {
+            console.error('❌ package.json not found in current directory!');
+            return;
+        }
+
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, { encoding: 'utf-8' }));
+        const scripts = packageJson.scripts || {};
+        
+        // Filter scripts that start with 'build-' but exclude 'build' itself
+        const buildScripts = Object.keys(scripts)
+            .filter(script => script.startsWith('build-') && script !== 'build')
+            .sort(); // Sort alphabetically for consistent execution order
+        
+        if (buildScripts.length === 0) {
+            console.warn('⚠️ No build-<project> scripts found in package.json');
+            return;
+        }
+
+        console.log(`📦 Found ${buildScripts.length} projects to build:\n`);
+        buildScripts.forEach((script, index) => {
+            console.log(`   ${index + 1}. ${script}`);
+        });
+        console.log('');
+
+        // Build each project sequentially
+        const results = [];
+        for (let i = 0; i < buildScripts.length; i++) {
+            const script = buildScripts[i];
+            const projectName = script.replace('build-', '');
+            
+            console.log(`\n${'='.repeat(60)}`);
+            console.log(`🔨 [${i + 1}/${buildScripts.length}] Building: ${projectName}`);
+            console.log(`${'='.repeat(60)}\n`);
+            
+            try {
+                // Run the build script
+                execSync(`npm run ${script}`, { 
+                    stdio: 'inherit',
+                    cwd: originalCwd
+                });
+                
+                results.push({ project: projectName, status: 'success' });
+                console.log(`\n✅ Successfully built: ${projectName}\n`);
+                
+            } catch (error) {
+                console.error(`\n❌ Failed to build: ${projectName}`);
+                console.error(`Error: ${error.message}\n`);
+                results.push({ project: projectName, status: 'failed', error: error.message });
+                
+                // Ask user if they want to continue with remaining builds
+                const readline = require('readline');
+                const rl = readline.createInterface({
+                    input: process.stdin,
+                    output: process.stdout
+                });
+                
+                const continueBuild = await new Promise((resolve) => {
+                    rl.question('Continue with remaining builds? (yes/no): ', (answer) => {
+                        rl.close();
+                        resolve(answer.toLowerCase() === 'yes' || answer.toLowerCase() === 'y');
+                    });
+                });
+                
+                if (!continueBuild) {
+                    console.log('\n⚠️ Build process stopped by user.');
+                    break;
+                }
+            }
+        }
+
+        // Print summary
+        console.log(`\n${'='.repeat(60)}`);
+        console.log('📊 Build Summary');
+        console.log(`${'='.repeat(60)}\n`);
+        
+        const successful = results.filter(r => r.status === 'success').length;
+        const failed = results.filter(r => r.status === 'failed').length;
+        
+        results.forEach((result, index) => {
+            const icon = result.status === 'success' ? '✅' : '❌';
+            console.log(`${icon} ${index + 1}. ${result.project}: ${result.status}`);
+            if (result.error) {
+                console.log(`   Error: ${result.error}`);
+            }
+        });
+        
+        console.log(`\n📈 Total: ${results.length} | ✅ Success: ${successful} | ❌ Failed: ${failed}\n`);
+        
+        if (failed === 0) {
+            console.log('🎉 All projects built successfully!\n');
+        } else {
+            console.log(`⚠️ ${failed} project(s) failed to build.\n`);
+        }
+        
+    } catch (error) {
+        console.error('❌ Error during build-all process:', error.message);
+    } finally {
+        // Always return to original directory
+        process.chdir(originalCwd);
+    }
+}
+
+module.exports = buildAllProjects;
+
+
+
+
+
+
+

package/buildProject.js

@@ -0,0 +1,209 @@
+const { execSync } = require('child_process');
+const { readFileSync, writeFileSync, existsSync } = require('fs');
+const fs = require('fs');
+const path = require('path');
+const { resolveNgProjectNameForPackageDir } = require('./resolveNgProjectName');
+
+function readJsonSafe(p) {
+    try {
+        return JSON.parse(readFileSync(p, { encoding: 'utf-8' }));
+    } catch {
+        return null;
+    }
+}
+
+/** e.g. "@cloudidesys/cloud-ide-element" -> "cloud-ide-element" (folder under projects/) */
+function folderNameFromProjectArg(projectName) {
+    const s = String(projectName).trim();
+    if (!s) return s;
+    const parts = s.split(/[/\\]/);
+    return parts[parts.length - 1] || s;
+}
+
+function resolveAngularDistFromNgPackage(projectAbsDir, workspaceRoot, distPathDefault) {
+    const ngPkgPath = path.join(projectAbsDir, 'ng-package.json');
+    if (existsSync(ngPkgPath)) {
+        const ngPkg = readJsonSafe(ngPkgPath);
+        if (ngPkg && ngPkg.dest) {
+            return path.resolve(projectAbsDir, ngPkg.dest);
+        }
+    }
+    const folderName = path.basename(projectAbsDir);
+    const scoped = path.join(workspaceRoot, distPathDefault || 'dist', '@cloudidesys', folderName);
+    if (existsSync(scoped)) return scoped;
+    return path.join(workspaceRoot, distPathDefault || 'dist', folderName);
+}
+
+async function buildProject(projectName, shouldInstall = false, options = {}) {
+  const force = !!options.force;
+    console.log(`Building project: ${projectName}`);
+    
+    // Store the original working directory
+    const originalCwd = process.cwd();
+    
+    try {
+        // For Angular workspaces, check if we're in the root workspace
+        // Projects are typically in the 'projects' folder
+        const projectsPath = path.join(originalCwd, 'projects');
+        const folderName = folderNameFromProjectArg(projectName);
+        const projectPath = path.join(projectsPath, folderName);
+        
+        // Check if projects folder exists (Angular workspace structure)
+        if (!existsSync(projectsPath)) {
+            console.error(`Projects folder not found! Make sure you're in an Angular workspace root.`);
+            return;
+        }
+        
+        // Check if specific project exists in projects folder
+        if (!existsSync(projectPath)) {
+            console.error(`Project '${projectName}' not found in projects folder!`);
+            console.log(`Available projects: ${fs.readdirSync(projectsPath).join(', ')}`);
+            return;
+        }
+
+        console.log(`Found Angular project: ${projectPath}`);
+        console.log(`Working from Angular workspace root: ${originalCwd}`);
+
+        // Read project configuration from workspace root
+        const cidePath = path.join(originalCwd, 'cide.json');
+        if (!existsSync(cidePath)) {
+            console.error(`cide.json not found in workspace root!`);
+            return;
+        }
+
+        const cide = JSON.parse(readFileSync(cidePath, { encoding: 'utf-8' }));
+        const packageJsonPath = path.join(projectPath, 'package.json');
+        const ngProjectName = resolveNgProjectNameForPackageDir(originalCwd, path.resolve(projectPath), packageJsonPath);
+        
+        // Step 1: Increment version in project's package.json
+        await incrementVersion(projectPath);
+        
+        // Step 2: Run build command
+        await runBuildCommand(cide, ngProjectName);
+        
+        // Step 3: Navigate to dist folder and publish
+        await publishFromDist(originalCwd, projectPath, cide);
+        
+        // Step 4: Install at root if --install flag is provided
+        if (shouldInstall) {
+            const pkg = readJsonSafe(path.join(projectPath, 'package.json'));
+            const depName = (pkg && pkg.name) ? pkg.name : folderName;
+            await installAtRoot(originalCwd, depName, force);
+        }
+        
+        console.log(`✅ Project '${projectName}' built and published successfully!`);
+        
+    } catch (error) {
+        console.error('Error during build process:', error.message);
+    } finally {
+        // Always return to original directory
+        process.chdir(originalCwd);
+    }
+}
+
+async function incrementVersion(projectPath) {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    
+    if (!existsSync(packageJsonPath)) {
+        console.warn('package.json not found, skipping version increment');
+        return;
+    }
+
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, { encoding: 'utf-8' }));
+    
+    if (!packageJson.version) {
+        console.warn('No version found in package.json, skipping version increment');
+        return;
+    }
+
+    // Parse current version
+    const versionParts = packageJson.version.split('.');
+    const patch = parseInt(versionParts[2]) || 0;
+    
+    // Increment patch version
+    versionParts[2] = (patch + 1).toString();
+    packageJson.version = versionParts.join('.');
+    
+    // Write updated package.json
+    writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    console.log(`📦 Version incremented to: ${packageJson.version}`);
+}
+
+async function runBuildCommand(cide, projectName) {
+    let buildCommand = "";
+    
+    if (cide?.templete === 'node') {
+        buildCommand = "npx tsc";
+    } else if (cide?.templete === 'react') {
+        buildCommand = "npm run build";
+    } else if (cide?.templete === 'angular') {
+        // For Angular projects, build specific library/project
+        buildCommand = `ng build --project ${projectName}`;
+    } else {
+        // Try to use custom build command from cide.json
+        buildCommand = cide?.build_command || `npm run build ${projectName}`;
+    }
+
+    if (buildCommand) {
+        console.log(`🔨 Running build command: ${buildCommand}`);
+        try {
+            execSync(buildCommand, { stdio: 'inherit', shell: true });
+            console.log('✅ Build completed successfully');
+        } catch (error) {
+            console.error('❌ Build failed:', error.message);
+            throw error;
+        }
+    } else {
+        console.warn('No build command specified in cide.json');
+    }
+}
+
+async function publishFromDist(workspaceRoot, projectAbsDir, cide) {
+    const distPath = cide?.dist_path || 'dist';
+    const fullDistPath = resolveAngularDistFromNgPackage(projectAbsDir, workspaceRoot, distPath);
+    
+    if (!existsSync(fullDistPath)) {
+        console.error(`Dist folder '${fullDistPath}' not found!`);
+        return;
+    }
+
+    console.log(`📁 Navigating to dist folder: ${fullDistPath}`);
+    process.chdir(fullDistPath);
+
+    // Check if package.json exists in dist folder
+    const distPackageJsonPath = path.join(fullDistPath, 'package.json');
+    if (!existsSync(distPackageJsonPath)) {
+        console.warn('package.json not found in dist folder, skipping publish');
+        return;
+    }
+
+    // Publish the package
+    console.log('📤 Publishing package from dist folder...');
+    try {
+        execSync('npm publish', { stdio: 'inherit' });
+        console.log('✅ Package published successfully');
+    } catch (error) {
+        console.error('❌ Package publish failed:', error.message);
+        throw error;
+    }
+}
+
+async function installAtRoot(rootPath, projectName, force = false) {
+    console.log(`📥 Updating package '${projectName}' at root...`);
+    
+    // Return to root directory
+    process.chdir(rootPath);
+    
+    try {
+        // Update the package and save to package.json dependencies
+        const forceFlag = force ? ' --force' : '';
+        console.log(force ? `npm update --save ${projectName} --force` : `npm update --save ${projectName}`);
+        execSync(`npm update --save ${projectName}${forceFlag}`, { stdio: 'inherit' });
+        console.log(`✅ Package '${projectName}' updated successfully at root`);
+    } catch (error) {
+        console.error(`❌ Failed to update package '${projectName}' at root:`, error.message);
+        throw error;
+    }
+}
+
+module.exports = buildProject;

package/buildWorkspace.js

@@ -0,0 +1,225 @@
+/**
+ * cide build — same numbered package list as publish; runs ng build / npm run build only (no bump, no registry publish).
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const readline = require('readline');
+const publishPackage = require('./publishPackage');
+const { resolveNgProjectNameForPackageDir } = require('./resolveNgProjectName');
+
+const loadCideConfig = publishPackage.loadCideConfig;
+const discoverPublishablePackages = publishPackage.discoverPublishablePackages;
+const parsePackagePublishSpec = publishPackage.parsePackagePublishSpec;
+
+function question(rl, prompt) {
+  return new Promise((resolve) => {
+    rl.question(prompt, (answer) => resolve(answer));
+  });
+}
+
+function printBuildUsageBox() {
+  console.log(`
+----------------------------------------------------------------
+ HOW TO BUILD (workspace) — same numbers as cide publish
+----------------------------------------------------------------
+  Builds only (no version bump, no npm publish):
+    1                 single package
+    1,3,5             several
+    1-5               range
+    all               every package in the list
+
+  CANCEL: q
+
+  Non-interactive:
+  cide build -p 1
+  cide build -p all --continue-on-error
+
+  After a failure (interactive):
+  [r] re-runs the same ng build / npm run build for that package, then continues to the next on success.
+  [y] skips to the next package. [N] stops and prints resume commands.
+
+  Non-interactive after a failure:
+  cide build -p all --resume-from 5
+----------------------------------------------------------------
+`);
+}
+
+/**
+ * @param {object} [options]
+ * @param {string} [options.packages] - -p / --packages
+ * @param {import('readline').Interface} [options.readlineInterface]
+ * @param {boolean} [options.continueOnError]
+ * @param {string|number} [options.resumeFrom]
+ */
+async function buildWorkspace(options = {}) {
+  const cliPackages = options.packages != null ? String(options.packages).trim() : '';
+  const fromCli = cliPackages.length > 0;
+
+  const angularRoot = process.cwd();
+  const { cide, monorepoRoot } = loadCideConfig(angularRoot);
+
+  if (!fs.existsSync(path.join(angularRoot, 'cide.json'))) {
+    console.warn('No cide.json in current directory — using cwd as both angular and monorepo root.');
+  }
+
+  console.log('\nScanning workspace for buildable packages (same list as publish)...\n');
+  const packages = discoverPublishablePackages({ cide, angularRoot, monorepoRoot });
+  if (!packages.length) {
+    console.error('No publishable packages found (same discovery as publish — need publishConfig.registry → GitHub Packages).');
+    console.error('Check cide.json workspace_root / sibling_packages and package publishConfig.');
+    return;
+  }
+
+  if (!fromCli) {
+    printBuildUsageBox();
+  }
+
+  console.log('Buildable packages:\n');
+  packages.forEach((p, i) => {
+    const rel = p.labelRel || p.folderName;
+    console.log(`  [${i + 1}]  ${p.name.padEnd(42)} v${p.version}    (${rel})`);
+  });
+
+  const ownsReadline = !options.readlineInterface;
+  const rl = options.readlineInterface || readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    let parsed;
+    if (fromCli) {
+      parsed = parsePackagePublishSpec(cliPackages, packages.length);
+      if (!parsed.ok) {
+        if (parsed.error !== 'cancelled') console.error(parsed.error || 'Invalid --packages');
+        return;
+      }
+    } else {
+      const raw = await question(rl, '\nYour choice (see HOW TO BUILD above): ');
+      parsed = parsePackagePublishSpec(raw, packages.length);
+      if (!parsed.ok) {
+        if (parsed.error !== 'cancelled') console.error(parsed.error || 'Invalid input.');
+        console.log('Aborted.');
+        return;
+      }
+    }
+
+    const { indices } = parsed;
+
+    const rawResume = options.resumeFrom != null ? String(options.resumeFrom).trim() : '';
+    const parsedResume = rawResume === '' ? 1 : parseInt(rawResume, 10);
+    const startStep = Number.isFinite(parsedResume) && parsedResume >= 1 ? parsedResume : 1;
+    if (startStep > indices.length) {
+      console.error(
+        `--resume-from ${startStep} is past the end of this batch (${indices.length} step(s)). Nothing to do.`
+      );
+      return;
+    }
+    if (startStep > 1) {
+      console.log(
+        `\n(Resuming: skipping batch steps 1..${startStep - 1}, starting at step ${startStep}/${indices.length})\n`
+      );
+    }
+
+    const continueOnError = !!options.continueOnError;
+
+    let builtOk = 0;
+    let skippedAfterFailure = 0;
+
+    function printBuildResumeHints(failedStep, nextStep, total) {
+      const pSpec = fromCli && cliPackages ? cliPackages : '<same -p as before (e.g. all)>';
+      console.log('\nAfter fixing the issue:');
+      console.log(`  • Retry same step:    cide build -p ${pSpec} --resume-from ${failedStep}`);
+      if (nextStep <= total) {
+        console.log(`  • Continue from next: cide build -p ${pSpec} --resume-from ${nextStep}`);
+      }
+    }
+
+    for (let k = startStep - 1; k < indices.length; k++) {
+      const idx = indices[k];
+      const entry = packages[idx];
+      const n = k + 1;
+      const total = indices.length;
+
+      let stepComplete = false;
+      while (!stepComplete) {
+        console.log(`\n--- Building ${n}/${total}: ${entry.name} ---`);
+
+        const originalCwd = process.cwd();
+
+        try {
+          if (entry.kind === 'angular-lib') {
+            if (cide.templete !== 'angular') {
+              console.warn('  Warning: cide.templete is not "angular"; still running ng build.');
+            }
+            const ngProjectName = resolveNgProjectNameForPackageDir(
+              angularRoot,
+              entry.absDir,
+              entry.packageJsonPath
+            );
+            console.log(`  ng build --project "${ngProjectName}"`);
+            execSync(`ng build --project "${ngProjectName}"`, { cwd: angularRoot, stdio: 'inherit', shell: true });
+          } else if (entry.hasBuildScript) {
+            console.log('  npm run build');
+            execSync('npm run build', { cwd: entry.absDir, stdio: 'inherit' });
+          } else {
+            console.warn('  ⚠ Skipping (no ng project and no build script).');
+            throw new Error('No build script for this package.');
+          }
+
+          builtOk++;
+          stepComplete = true;
+        } catch (err) {
+          console.error(`  ❌ Failed: ${err.message}`);
+          process.chdir(originalCwd);
+
+          const nextStep = k + 2;
+          const canAsk =
+            rl && (process.stdin.isTTY || options.readlineInterface) && !continueOnError;
+
+          if (continueOnError) {
+            skippedAfterFailure++;
+            console.log('  (--continue-on-error: continuing with remaining packages.)');
+            stepComplete = true;
+          } else if (!canAsk) {
+            console.error('\nStopped.');
+            console.error('(Non-interactive: add --continue-on-error to keep going, or use --resume-from.)');
+            printBuildResumeHints(n, nextStep, total);
+            throw err;
+          } else {
+            const ans = await question(
+              rl,
+              '\n[y] skip to next package / [r]etry this step (re-run same command) / [N] stop: '
+            );
+            const a = String(ans).trim().toLowerCase();
+            if (a === 'r' || a === 'retry') {
+              console.log(`\n  ↻ Retrying step ${n}/${total} (${entry.name})...\n`);
+              continue;
+            } else if (/^y(es)?$/i.test(a)) {
+              skippedAfterFailure++;
+              console.log('\n  (Skipping failed package; continuing with the rest.)');
+              stepComplete = true;
+            } else {
+              console.log('\nStopped.');
+              printBuildResumeHints(n, nextStep, total);
+              return;
+            }
+          }
+        } finally {
+          process.chdir(originalCwd);
+        }
+      }
+    }
+
+    if (skippedAfterFailure === 0) {
+      console.log(`\n✅ Built ${builtOk} package(s) successfully.\n`);
+    } else {
+      console.log(
+        `\n⚠️ Batch finished: ${builtOk} built OK, ${skippedAfterFailure} failed (skipped).\n`
+      );
+    }
+  } finally {
+    if (ownsReadline) rl.close();
+  }
+}
+
+module.exports = buildWorkspace;