coursecode 0.1.33 → 0.1.35

package/lib/cloud.js

@@ -941,7 +941,7 @@ export async function listCourses(options = {}) {
 }
 
 /**
- * coursecode deploy — build, zip, resolve org, upload
+ * coursecode deploy — build, read files, batch presign + upload + finalize
  */
 export async function deploy(options = {}) {
   const { validateProject } = await import('./project-utils.js');
@@ -951,6 +951,9 @@ export async function deploy(options = {}) {
   const slug = resolveSlug();
   const log = (...args) => { if (!options.json) console.log(...args); };
   const logErr = (...args) => { if (!options.json) console.error(...args); };
+  const emitProgress = (stage, uploaded, total) => {
+    if (options.json) process.stdout.write(JSON.stringify({ type: 'progress', stage, uploaded, total }) + '\n');
+  };
 
   // Preflight a cached binding so deleted cloud courses can be repaired
   // before we spend time building and uploading.
@@ -1034,11 +1037,10 @@ export async function deploy(options = {}) {
   // Determine promote_mode and preview_force
   const promoteMode = options.promote ? 'promote' : options.stage ? 'stage' : 'auto';
   const previewForce = !!options.preview;
-  // --preview alone = preview_only deploy (production pointer untouched, preview always moved)
-  // --preview + --promote/--stage = full production deploy + always move preview pointer
   const previewOnly = previewForce && promoteMode === 'auto';
 
   log('\n📦 Building...\n');
+  emitProgress('building');
 
   // Step 1: Build
   const { build } = await import('./build.js');
@@ -1052,15 +1054,45 @@ export async function deploy(options = {}) {
     process.exit(1);
   }
 
-  // Step 3: Resolve org
-  const { orgId, courseId, orgName } = await resolveOrgAndCourse(slug, readCredentials()?.token);
+  // Step 3: Resolve org + ensure course exists
+  const { orgId, courseId: existingCourseId, orgName } = await resolveOrgAndCourse(slug, readCredentials()?.token);
   const displayOrg = orgName ? ` to ${orgName}` : '';
 
-  // Step 4: Zip dist/ contents
-  const zipPath = path.join(os.tmpdir(), `coursecode-deploy-${Date.now()}.zip`);
-  await zipDirectory(distPath, zipPath);
+  // Ensure course exists on Cloud (resolve or create)
+  const ensureRes = await cloudFetch(
+    `/api/cli/courses/${encodeURIComponent(slug)}/ensure`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ orgId }),
+    },
+    readCredentials()?.token
+  );
+  const ensureData = await handleResponse(ensureRes);
+  const courseId = ensureData.courseId || existingCourseId;
+
+  // Server-side safety net: reject non-preview deploys for GitHub-linked courses
+  if (ensureData.githubRepo && !previewOnly) {
+    logErr('\n❌ This course deploys to production via GitHub, not CLI.');
+    logErr(`   Repo: ${ensureData.githubRepo}`);
+    logErr('   Push to your repo to trigger a production deploy.');
+    logErr('   Use --preview to deploy a preview build via CLI.\n');
+    if (options.json) {
+      process.stdout.write(JSON.stringify({
+        success: false,
+        error: 'Production deploy blocked — course is GitHub-linked',
+        errorCode: 'github_source_blocked',
+        githubRepo: ensureData.githubRepo,
+        hint: 'Use --preview for preview deploys, or push to GitHub for production.',
+      }) + '\n');
+    }
+    process.exit(1);
+  }
+
+  // Step 4: Read dist/ files
+  const distFiles = collectDistFiles(distPath);
+  const totalSize = distFiles.reduce((sum, f) => sum + f.size, 0);
 
-  // Step 5: Upload
   let modeLabel;
   if (previewOnly) {
     modeLabel = 'preview only';
@@ -1075,58 +1107,132 @@ export async function deploy(options = {}) {
   } else {
     modeLabel = 'production';
   }
-  log(`\nDeploying ${slug}${displayOrg} [${modeLabel}]...\n`);
+  log(`\nDeploying ${slug}${displayOrg} [${modeLabel}] — ${distFiles.length} files, ${formatBytes(totalSize)}\n`);
+
+  // Step 5: Batch presign
+  const presignRes = await cloudFetch(
+    `/api/courses/${courseId}/upload/presign/batch`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        files: distFiles.map(f => ({ path: f.relativePath, contentType: guessContentTypeLocal(f.relativePath) })),
+        totalSize,
+      }),
+    },
+    readCredentials()?.token
+  );
+  const presignData = await handleResponse(presignRes);
 
-  const formData = new FormData();
-  const zipBuffer = fs.readFileSync(zipPath);
-  formData.append('file', new Blob([zipBuffer], { type: 'application/zip' }), 'deploy.zip');
-  formData.append('orgId', orgId);
-  formData.append('promote_mode', promoteMode);
-  formData.append('preview_force', String(previewForce));
+  // Step 6: Upload files to R2 via presigned URLs
+  emitProgress('uploading', 0, distFiles.length);
+  log('  Uploading files...');
 
-  if (options.message) {
-    formData.append('message', options.message);
-  }
+  const CONCURRENCY = 8;
+  const MAX_RETRIES = 3;
+  let uploaded = 0;
 
-  if (options.preview && options.password) {
-    const pw = await prompt('  Preview password: ');
-    formData.append('password', pw);
+  const uploadQueue = presignData.uploads.map((u, i) => ({
+    uploadUrl: u.uploadUrl,
+    filePath: path.join(distPath, distFiles[i].relativePath),
+    contentType: guessContentTypeLocal(distFiles[i].relativePath),
+  }));
+
+  // Concurrent upload with retry
+  const chunks = [];
+  for (let i = 0; i < uploadQueue.length; i += CONCURRENCY) {
+    chunks.push(uploadQueue.slice(i, i + CONCURRENCY));
+  }
+
+  for (const chunk of chunks) {
+    await Promise.all(chunk.map(async (item) => {
+      const fileData = fs.readFileSync(item.filePath);
+      for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+        try {
+          const putRes = await fetch(item.uploadUrl, {
+            method: 'PUT',
+            headers: { 'Content-Type': item.contentType },
+            body: fileData,
+          });
+          if (!putRes.ok) {
+            throw new Error(`PUT failed: ${putRes.status}`);
+          }
+          break;
+        } catch (err) {
+          if (attempt === MAX_RETRIES - 1) throw err;
+          await new Promise(r => setTimeout(r, 500 * (attempt + 1)));
+        }
+      }
+      uploaded++;
+      emitProgress('uploading', uploaded, distFiles.length);
+      if (!options.json && process.stdout.isTTY) {
+        process.stdout.write(`\r  Uploading ${uploaded}/${distFiles.length} files...`);
+      }
+    }));
   }
 
-  const queryString = previewOnly ? '?mode=preview' : '';
+  if (!options.json && process.stdout.isTTY) process.stdout.write('\n');
+  log(`  ✓ Uploaded ${uploaded} files`);
 
-  const makeRequest = async (_isRetry = false) => {
-    const token = readCredentials()?.token;
-    const res = await cloudFetch(
-      `/api/cli/courses/${encodeURIComponent(slug)}/deploy${queryString}`,
-      { method: 'POST', body: formData },
-      token
-    );
-    return handleResponse(res, { retryFn: makeRequest, _isRetry });
+  // Step 7: Finalize
+  emitProgress('finalizing');
+
+  const finalizeBody = {
+    versionTimestamp: presignData.versionTimestamp,
+    filename: slug,
+    fileCount: distFiles.length,
+    totalSize,
+    promoteMode,
+    previewForce,
+    previewOnly,
   };
+  if (options.message) finalizeBody.message = options.message;
 
-  const result = await makeRequest();
+  const finalizeRes = await cloudFetch(
+    `/api/courses/${courseId}/upload/finalize`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(finalizeBody),
+    },
+    readCredentials()?.token
+  );
+  const result = await handleResponse(finalizeRes);
 
-  // Step 6: Persist per-user binding and stamp cloud identity into .coursecoderc.json
-  const finalCourseId = result.courseId || courseId;
-  writeProjectConfig({ slug, orgId: result.orgId || orgId, courseId: finalCourseId });
+  // Step 8: Persist per-user binding
+  writeProjectConfig({ slug, orgId: ensureData.orgId || orgId, courseId });
   writeRcConfig({
-    cloudId: finalCourseId,
-    orgId: result.orgId || orgId,
+    cloudId: courseId,
+    orgId: ensureData.orgId || orgId,
   });
 
-  // Step 7: Display result
+  // Step 9: Display result
+  const appUrl = getCloudUrl();
+  const dashboardUrl = `${appUrl}/dashboard/courses/${courseId}`;
+
   if (options.json) {
-    process.stdout.write(JSON.stringify({ success: true, ...result }) + '\n');
-  } else if (result.mode === 'preview') {
-    // preview_only=true deployment (--preview alone)
-    console.log(`✓ Preview deployed (${result.fileCount} files)`);
-    console.log(`  Preview URL: ${result.url}`);
-    console.log(`  Dashboard:   ${result.dashboardUrl}`);
+    process.stdout.write(JSON.stringify({
+      type: 'result',
+      success: true,
+      courseId,
+      slug,
+      mode: previewOnly ? 'preview' : 'production',
+      fileCount: distFiles.length,
+      size: totalSize,
+      deploymentId: result.deploymentId,
+      promoted: result.promoted,
+      previewPromoted: result.previewPromoted,
+      previewUrl: result.previewUrl,
+      dashboardUrl,
+    }) + '\n');
+  } else if (previewOnly) {
+    console.log(`✓ Preview deployed (${distFiles.length} files)`);
+    if (result.previewUrl) console.log(`  Preview URL: ${result.previewUrl}`);
+    console.log(`  Dashboard:   ${dashboardUrl}`);
   } else {
     const prodTag = result.promoted ? 'live' : 'staged';
     const previewTag = result.previewPromoted ? ' + preview' : '';
-    console.log(`✓ Deployed (${result.fileCount} files) — ${prodTag}${previewTag}`);
+    console.log(`✓ Deployed (${distFiles.length} files) — ${prodTag}${previewTag}`);
     if (!result.promoted) {
       console.log('  Production pointer not updated. Promote from Deploy History or run:');
       console.log('  coursecode promote --production');
@@ -1134,12 +1240,46 @@ export async function deploy(options = {}) {
     if (result.previewPromoted) {
       console.log('  Preview pointer updated.');
     }
-    console.log(`  Dashboard: ${result.dashboardUrl}`);
+    console.log(`  Dashboard: ${dashboardUrl}`);
   }
   console.log('');
+}
 
-  // Cleanup temp zip
-  try { fs.unlinkSync(zipPath); } catch { /* fine */ }
+/** Recursively collect all files in a directory with relative paths and sizes. */
+export function collectDistFiles(dirPath, basePath = '') {
+  const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
+    const fullPath = path.join(dirPath, entry.name);
+    if (entry.name === '__MACOSX' || entry.name.startsWith('.')) continue;
+    if (entry.isDirectory()) {
+      files.push(...collectDistFiles(fullPath, relativePath));
+    } else {
+      files.push({
+        relativePath,
+        fullPath,
+        size: fs.statSync(fullPath).size,
+      });
+    }
+  }
+  return files;
+}
+
+/** Minimal content-type guesser for CLI uploads. */
+export function guessContentTypeLocal(filePath) {
+  const ext = filePath.split('.').pop()?.toLowerCase();
+  const types = {
+    html: 'text/html', htm: 'text/html', css: 'text/css',
+    js: 'application/javascript', mjs: 'application/javascript',
+    json: 'application/json', xml: 'application/xml',
+    svg: 'image/svg+xml', png: 'image/png', jpg: 'image/jpeg',
+    jpeg: 'image/jpeg', gif: 'image/gif', webp: 'image/webp',
+    mp4: 'video/mp4', webm: 'video/webm', mp3: 'audio/mpeg',
+    wav: 'audio/wav', woff: 'font/woff', woff2: 'font/woff2',
+    ttf: 'font/ttf', pdf: 'application/pdf', txt: 'text/plain',
+  };
+  return types[ext] || 'application/octet-stream';
 }
 
 /**
@@ -1645,23 +1785,3 @@ export async function deleteCourse(options = {}) {
   console.log('');
 }
 
-// =============================================================================
-// ZIP HELPER
-// =============================================================================
-
-/**
- * Zip a directory's contents using archiver (cross-platform, no native tools needed).
- */
-async function zipDirectory(sourceDir, outputPath) {
-  const archiver = (await import('archiver')).default;
-  return new Promise((resolve, reject) => {
-    const output = fs.createWriteStream(outputPath);
-    const archive = archiver('zip', { zlib: { level: 9 } });
-
-    output.on('close', () => resolve());
-    archive.on('error', reject);
-    archive.pipe(output);
-    archive.directory(sourceDir, false);
-    archive.finalize();
-  });
-}

package/lib/headless-browser.js

@@ -72,6 +72,8 @@ class HeadlessBrowser {
         this._stopped = false;
         this._consoleLogs = [];
         this._viewport = { width: 1280, height: 720 };
+        /** @type {Promise<void>|null} Tracks an in-flight reload so tool calls wait for it */
+        this._reloadPromise = null;
     }
 
     /**
@@ -136,6 +138,11 @@ class HeadlessBrowser {
      * @private
      */
     async _navigateToPreview() {
+        // Clear stale console errors from the previous page load.
+        // The page.goto() below will trigger teardown console noise from the
+        // dying page — we only want post-reload errors.
+        this._consoleLogs = [];
+
         const url = `http://localhost:${this.port}?headless`;
         await this.page.goto(url, { waitUntil: 'domcontentloaded', timeout: 3000 });
 
@@ -189,10 +196,16 @@ class HeadlessBrowser {
                     if (this._stopped) return;
                     const data = chunk.toString();
                     if (data.includes('data: reload')) {
+                        // Track the reload so concurrent tool calls wait for it
+                        let resolveReload;
+                        this._reloadPromise = new Promise(r => { resolveReload = r; });
                         try {
                             await this._navigateToPreview();
                         } catch (_e) {
                             // Preview may be mid-rebuild, retry will happen on next SSE
+                        } finally {
+                            this._reloadPromise = null;
+                            resolveReload();
                         }
                     }
                 });
@@ -425,9 +438,24 @@ class HeadlessBrowser {
      * @private
      */
     async _ensureCourseFrame() {
+        // If an SSE-triggered reload is in progress, wait for it to finish.
+        // This prevents tool calls from hitting a mid-reinitializing framework
+        // ("NavigationActions not initialized" errors after file edits).
+        if (this._reloadPromise) {
+            await this._reloadPromise;
+        }
+
         try {
-            // Quick check that the frame is still attached
-            await this.courseFrame.evaluate(() => true);
+            // Check that the frame is still attached AND the framework is ready.
+            // The stub player (in-page JS) may reload the iframe before the Node-side
+            // SSE handler sets _reloadPromise, so we must also verify readiness here.
+            const ready = await this.courseFrame.evaluate(
+                () => window.CourseCodeAutomation?.ready === true
+            );
+            if (!ready) {
+                // Frame is attached but framework is reinitializing — wait for it
+                await this._locateCourseFrame();
+            }
         } catch (_e) {
             // Frame detached (page reloaded), re-locate it
             await this._locateCourseFrame();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coursecode",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "Multi-format course authoring framework with CLI tools (SCORM 2004, SCORM 1.2, cmi5, LTI 1.3)",
   "type": "module",
   "bin": {

package/template/package.json

@@ -19,10 +19,10 @@
     "marked-gfm-heading-id": "^4.1.3"
   },
   "devDependencies": {
-    "@vitejs/plugin-legacy": "^7.2.1",
+    "@vitejs/plugin-legacy": "~7.2.1",
     "archiver": "^7.0.1",
     "eslint": "^9.39.1",
-    "vite": "^7.2.2",
+    "vite": "~7.2.2",
     "vite-plugin-static-copy": "^3.1.4"
   }
 }