coursecode 0.1.14 → 0.1.16

package/bin/cli.js

@@ -393,6 +393,25 @@ program
     await status({ json: options.json, repairBinding: options.repairBinding });
   });
 
+program
+  .command('preview-link')
+  .description('Show or update the Cloud preview link for the current course')
+  .option('--enable', 'Enable the preview link. Creates one if missing.')
+  .option('--disable', 'Disable the preview link')
+  .option('--password [password]', 'Set or update the preview password. Prompts if no value is provided.')
+  .option('--remove-password', 'Remove the preview password')
+  .option('--format <format>', 'Preview format: cmi5, scorm2004, scorm1.2')
+  .option('--expires-at <iso>', 'Set preview expiry timestamp (ISO 8601)')
+  .option('--expires-in-days <days>', 'Set preview expiry relative to now')
+  .option('--repair-binding', 'Clear a stale local Cloud binding if the remote course was deleted')
+  .option('--local', 'Use local Cloud instance (http://localhost:3000)')
+  .option('--json', 'Output raw JSON')
+  .action(async (options) => {
+    const { previewLink, setLocalMode } = await import('../lib/cloud.js');
+    if (options.local) setLocalMode();
+    await previewLink(options);
+  });
+
 program
   .command('delete')
   .description('Remove course from CourseCode Cloud (does not delete local files)')

package/framework/js/core/event-bus.js

@@ -1,10 +1,38 @@
 import { generateId } from '../utilities/utilities.js';
 import { logger } from '../utilities/logger.js';
 
+/**
+ * Safely serialize any value for logging. Handles circular references,
+ * Error instances, and oversized payloads without throwing.
+ */
+function safeStringify(data, maxLength = 4096) {
+  const seen = new WeakSet();
+  try {
+    const json = JSON.stringify(data, (key, value) => {
+      if (value instanceof Error) {
+        return { name: value.name, message: value.message, stack: value.stack };
+      }
+      if (typeof value === 'object' && value !== null) {
+        if (seen.has(value)) return '[Circular]';
+        seen.add(value);
+      }
+      return value;
+    }, 2);
+    if (json && json.length > maxLength) {
+      return json.slice(0, maxLength) + '...[truncated]';
+    }
+    return json;
+  } catch {
+    return `[Unserializable: ${typeof data}]`;
+  }
+}
+
 class EventBus {
   constructor() {
     // Event listeners registry
     this.events = {};
+    // Re-entrancy guard — prevents infinite :error → log → :error cascade
+    this._emittingError = false;
   }
 
   /**
@@ -86,31 +114,50 @@ class EventBus {
       return false;
     }
 
-    // Automatically log events that follow the ':error' naming convention
-    if (event.endsWith(':error')) {
-      logger.error(`[EventBus Error] ${event}:`, JSON.stringify(data, null, 2));
-    }
+    const isErrorEvent = event.endsWith(':error');
 
-    // Create a copy of listeners to avoid issues if listeners modify the array
-    const listeners = [...this.events[event]];
-    const onceListeners = [];
+    // Re-entrancy guard — if we're already inside an :error emit,
+    // suppress to prevent infinite cascade
+    if (isErrorEvent) {
+      if (this._emittingError) {
+        console.warn(`[EventBus] Suppressed recursive error event: ${event}`);
+        return false;
+      }
+      this._emittingError = true;
+    }
 
-    listeners.forEach(listener => {
-      try {
-        listener.callback(data);
+    try {
+      // Automatically log events that follow the ':error' naming convention
+      if (isErrorEvent) {
+        logger.error(`[EventBus Error] ${event}:`, safeStringify(data));
+      }
 
-        // Track once listeners for removal
-        if (listener.once) {
-          onceListeners.push(listener.id);
+      // Create a copy of listeners to avoid issues if listeners modify the array
+      const listeners = [...this.events[event]];
+      const onceListeners = [];
+
+      listeners.forEach(listener => {
+        try {
+          listener.callback(data);
+
+          // Track once listeners for removal
+          if (listener.once) {
+            onceListeners.push(listener.id);
+          }
+        } catch (error) {
+          // Log the error but don't break other listeners — use safeStringify
+          // to prevent a secondary cascade from unserializable error objects
+          logger.error(`[EventBus] Error in listener for '${event}':`, safeStringify(error));
         }
-      } catch (error) {
-        // Log the error but don't break other listeners
-        logger.error(`[EventBus] Error in listener for '${event}':`, error);
-      }
-    });
+      });
 
-    // Remove once listeners
-    onceListeners.forEach(id => this.off(event, id));
+      // Remove once listeners
+      onceListeners.forEach(id => this.off(event, id));
+    } finally {
+      if (isErrorEvent) {
+        this._emittingError = false;
+      }
+    }
 
     return true;
   }

package/framework/js/drivers/scorm-2004-driver.js

@@ -561,13 +561,27 @@ export class Scorm2004Driver extends ScormDriverBase {
      * Populates the CMI cache at init time. Single LMS read pass.
      */
     _populateCache() {
-        // Read-only scalars
-        this._cmiCache.entry = this._getValue('cmi.entry') || '';
-        this._cmiCache.bookmark = this._getValue('cmi.location') || '';
-        this._cmiCache.completionStatus = this._getValue('cmi.completion_status') || 'unknown';
-        this._cmiCache.successStatus = this._getValue('cmi.success_status') || 'unknown';
-        this._cmiCache.learnerId = this._getValue('cmi.learner_id') || '';
-        this._cmiCache.learnerName = this._getValue('cmi.learner_name') || '';
+        // Helper: read a CMI value via strict _getValue, but tolerate error 403
+        // ("Data Model Element Value Not Initialized") which strict LMSes like
+        // SCORM Cloud return for unset elements on a fresh session.
+        // Any other SCORM error still throws through _getValue's normal path.
+        const getOrDefault = (key, fallback) => {
+            try {
+                return this._getValue(key) || fallback;
+            } catch (e) {
+                const code = this._scorm.debug.getCode();
+                if (code === 403) return fallback;
+                throw e;
+            }
+        };
+
+        // Read-only scalars (may be uninitialized on first launch)
+        this._cmiCache.entry = getOrDefault('cmi.entry', '');
+        this._cmiCache.bookmark = getOrDefault('cmi.location', '');
+        this._cmiCache.completionStatus = getOrDefault('cmi.completion_status', 'unknown');
+        this._cmiCache.successStatus = getOrDefault('cmi.success_status', 'unknown');
+        this._cmiCache.learnerId = getOrDefault('cmi.learner_id', '');
+        this._cmiCache.learnerName = getOrDefault('cmi.learner_name', '');
 
         // Skip array hydration for fresh sessions
         if (this._cmiCache.entry === 'ab-initio') {

package/lib/cloud.js

@@ -463,7 +463,7 @@ function handleResponseError(status, body) {
   if (status === 403 || status === 409) {
     console.error(`\n❌ ${message}\n`);
   } else if (status === 404) {
-    console.error('\n❌ Course not found on Cloud.\n');
+    console.error(`\n❌ ${message === 'Course not found' ? 'Course not found on Cloud.' : message}\n`);
   } else if (status >= 500) {
     console.error('\n❌ Cloud server error. Try again later.\n');
   } else {
@@ -799,6 +799,33 @@ function formatDate(isoString) {
   });
 }
 
+function formatDeploymentSummary(deployment) {
+  if (!deployment) return 'none';
+  const parts = [deployment.versionTimestamp || deployment.deploymentId];
+  if (deployment.source) parts.push(deployment.source);
+  if (deployment.previewOnly) parts.push('preview-only');
+  if (deployment.fileCount != null) parts.push(`${deployment.fileCount} files`);
+  if (deployment.commitSha) parts.push(deployment.commitSha.slice(0, 7));
+  return parts.join(' | ');
+}
+
+function formatPreviewState(state) {
+  if (!state) return 'missing';
+  return state.replace('_', ' ');
+}
+
+function printPreviewLinkDetails(previewLink) {
+  if (!previewLink || !previewLink.exists) {
+    console.log('Preview Link:   missing');
+    return;
+  }
+
+  console.log(`Preview Link:   ${formatPreviewState(previewLink.state)}`);
+  console.log(`                ${previewLink.url}`);
+  if (previewLink.expiresAt) console.log(`                Expires ${formatDate(previewLink.expiresAt)}`);
+  console.log(`                Format ${previewLink.format} | ${previewLink.hasPassword ? 'password protected' : 'no password'} | ${previewLink.source}`);
+}
+
 // =============================================================================
 // CLI COMMANDS
 // =============================================================================
@@ -1274,27 +1301,182 @@ export async function status(options = {}) {
 
   console.log(`\n${data.slug} — ${data.name} (${data.orgName})\n`);
 
-  if (data.source_type === 'github' && data.github_repo) {
+  if (data.source?.type === 'github' && data.source?.githubRepo) {
+    console.log(`Source:         GitHub — ${data.source.githubRepo}`);
+    console.log('                direct production deploy disabled; preview deploy allowed');
+  } else if (data.source_type === 'github' && data.github_repo) {
     console.log(`Source:         GitHub — ${data.github_repo}`);
     console.log(`                (changes deploy via GitHub, not direct upload)`);
   } else if (data.source_type) {
     console.log(`Source:         ${data.source_type}`);
   }
 
+  if (data.courseId) console.log(`Course ID:      ${data.courseId}`);
+
   if (data.lastDeploy) {
     console.log(`Last deploy:    ${formatDate(data.lastDeploy)} (${data.lastDeployFileCount} files, ${formatBytes(data.lastDeploySize)})`);
   } else {
     console.log('Last deploy:    Never');
   }
 
-  if (data.errorCount24h != null) console.log(`Errors (24h):   ${data.errorCount24h}`);
-  if (data.launchCount24h != null) console.log(`Launches (24h): ${data.launchCount24h}`);
+  console.log(`Production:     ${formatDeploymentSummary(data.production)}`);
+  console.log(`Preview Ptr:    ${formatDeploymentSummary(data.previewPointer)}`);
+  if (data.health) {
+    console.log(`Pointer Drift:  ${data.health.previewMatchesProduction ? 'preview matches production' : 'preview differs from production'}`);
+  }
+  if (data.deployModes) {
+    console.log(`Deploy Modes:   production=${data.deployModes.production} | preview=${data.deployModes.preview}`);
+  }
+
+  if (data.activity?.errorCount24h != null) console.log(`Errors (24h):   ${data.activity.errorCount24h}`);
+  else if (data.errorCount24h != null) console.log(`Errors (24h):   ${data.errorCount24h}`);
+
+  if (data.activity?.launchCount24h != null) console.log(`Launches (24h): ${data.activity.launchCount24h}`);
+  else if (data.launchCount24h != null) console.log(`Launches (24h): ${data.launchCount24h}`);
+
+  if (data.activity?.lastErrorAt) console.log(`Last error:     ${formatDate(data.activity.lastErrorAt)}`);
+  if (data.activity?.lastLaunchAt) console.log(`Last launch:    ${formatDate(data.activity.lastLaunchAt)}`);
+
+  printPreviewLinkDetails(data.previewLink);
+
+  console.log('');
+}
+
+/**
+ * coursecode preview-link — show or update the current preview link
+ */
+export async function previewLink(options = {}) {
+  await ensureAuthenticated();
+  const slug = resolveSlug();
+  const rcConfig = readRcConfig();
+  const orgQuery = rcConfig?.orgId ? `?orgId=${rcConfig.orgId}` : '';
+
+  if (options.enable && options.disable) {
+    console.error('\n❌ Specify only one of --enable or --disable\n');
+    process.exit(1);
+  }
+
+  if (options.password !== undefined && options.removePassword) {
+    console.error('\n❌ --password and --remove-password are mutually exclusive\n');
+    process.exit(1);
+  }
+
+  if (options.expiresAt && options.expiresInDays) {
+    console.error('\n❌ Specify only one of --expires-at or --expires-in-days\n');
+    process.exit(1);
+  }
+
+  if (options.format && !['cmi5', 'scorm2004', 'scorm1.2'].includes(options.format)) {
+    console.error('\n❌ Preview format must be one of: cmi5, scorm2004, scorm1.2\n');
+    process.exit(1);
+  }
+
+  const hasMutation = Boolean(
+    options.enable
+    || options.disable
+    || options.password !== undefined
+    || options.removePassword
+    || options.format
+    || options.expiresAt
+    || options.expiresInDays
+  );
+
+  const body = {};
+  if (hasMutation) {
+    if (options.enable) body.enabled = true;
+    if (options.disable) body.enabled = false;
+    if (options.format) body.format = options.format;
+    if (options.expiresAt) body.expires_at = options.expiresAt;
+    if (options.expiresInDays) {
+      const days = Number.parseInt(String(options.expiresInDays), 10);
+      if (!Number.isFinite(days) || days <= 0) {
+        console.error('\n❌ --expires-in-days must be a positive integer\n');
+        process.exit(1);
+      }
+      body.expires_at = new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString();
+    }
+
+    if (options.password !== undefined) {
+      let pw = options.password;
+      if (pw === true || pw === '') pw = await prompt('  Preview password: ');
+      if (!pw) {
+        console.error('\n❌ Preview password cannot be empty\n');
+        process.exit(1);
+      }
+      body.password = pw;
+    }
+
+    if (options.removePassword) body.remove_password = true;
+  }
+
+  const requestOptions = hasMutation
+    ? {
+      method: 'PATCH',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    }
+    : {};
+
+  const makeRequest = async (_isRetry = false) => {
+    const token = readCredentials()?.token;
+    const res = await cloudFetch(
+      `/api/cli/courses/${encodeURIComponent(slug)}/preview${orgQuery}`,
+      requestOptions,
+      token
+    );
+    return handleResponse(res, { retryFn: makeRequest, _isRetry });
+  };
+
+  const token = readCredentials()?.token;
+  const firstRes = await cloudFetch(
+    `/api/cli/courses/${encodeURIComponent(slug)}/preview${orgQuery}`,
+    requestOptions,
+    token
+  );
+
+  if (firstRes.status === 404 && getBindingSnapshot(slug).hasBinding) {
+    const handled = await resolveStaleBinding({
+      operation: 'preview-link',
+      slug,
+      options,
+      promptText: '\n  This project is still linked locally, but the Cloud course was deleted. Clear the stale binding?',
+      onRepaired: (payload) => {
+        const result = {
+          ...payload,
+          success: true,
+          previewLink: null,
+          message: 'Local stale Cloud binding cleared. This course is no longer deployed.',
+        };
+        if (options.json) {
+          emitJson(result);
+        } else {
+          console.log('\n  Cleared stale Cloud binding.');
+          console.log('  This course is no longer deployed. Run `coursecode deploy` to create a new Cloud deployment.\n');
+        }
+        return true;
+      },
+      onJson: (payload) => {
+        emitJson(payload);
+        return true;
+      },
+    });
+    if (handled) return;
+  }
+
+  const data = await handleResponse(firstRes, { retryFn: makeRequest, _isRetry: false });
+
+  if (options.json) {
+    emitJson(data);
+    return;
+  }
 
-  if (data.previewUrl) {
-    console.log(`Preview:        ${data.previewUrl}`);
-    if (data.previewExpiresAt) console.log(`                Expires ${formatDate(data.previewExpiresAt)}`);
+  if (hasMutation) {
+    console.log(`\n✓ Preview link ${data.created ? 'created' : 'updated'}.\n`);
+  } else {
+    console.log(`\n${slug} — Preview Link\n`);
   }
 
+  printPreviewLinkDetails(data.previewLink);
   console.log('');
 }
 

package/package.json

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