@patch-adams/core 1.0.5 → 1.0.7

package/dist/cli.cjs

@@ -0,0 +1,1121 @@
+#!/usr/bin/env node
+'use strict';
+
+var commander = require('commander');
+var fs = require('fs');
+var path = require('path');
+var chalk = require('chalk');
+var ora = require('ora');
+var AdmZip = require('adm-zip');
+var fastXmlParser = require('fast-xml-parser');
+var zod = require('zod');
+var url = require('url');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+var ora__default = /*#__PURE__*/_interopDefault(ora);
+var AdmZip__default = /*#__PURE__*/_interopDefault(AdmZip);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/detectors/format-detector.ts
+var FormatDetector;
+var init_format_detector = __esm({
+  "src/detectors/format-detector.ts"() {
+    FormatDetector = class {
+      /**
+       * Detect the package format from a ZIP file
+       */
+      detect(zip) {
+        if (zip.getEntry("cmi5.xml")) {
+          return "cmi5";
+        }
+        if (zip.getEntry("tincan.xml")) {
+          return "xapi";
+        }
+        const manifest = zip.getEntry("imsmanifest.xml");
+        if (manifest) {
+          const content = manifest.getData().toString("utf-8");
+          return this.detectScormVersion(content);
+        }
+        if (this.hasAiccFiles(zip)) {
+          return "aicc";
+        }
+        return "unknown";
+      }
+      /**
+       * Detect SCORM version from manifest content
+       */
+      detectScormVersion(content) {
+        if (content.includes("4th Edition") || content.includes("CAM 1.4")) {
+          return "scorm2004-4";
+        }
+        if (content.includes("3rd Edition") || content.includes("2004 3rd") || content.includes("adlcp_v1p3")) {
+          return "scorm2004-3";
+        }
+        if (content.includes("2004") && content.includes("adlseq")) {
+          return "scorm2004-3";
+        }
+        if (content.includes("1.2") || content.includes("adlcp_rootv1p2") || content.includes("imscp_rootv1p1p2")) {
+          return "scorm12";
+        }
+        if (content.toLowerCase().includes("aicc")) {
+          return "aicc";
+        }
+        return "scorm12";
+      }
+      /**
+       * Check for AICC-specific files
+       */
+      hasAiccFiles(zip) {
+        const aiccExtensions = [".crs", ".au", ".des", ".cst"];
+        const entries = zip.getEntries();
+        for (const entry of entries) {
+          const name = entry.entryName.toLowerCase();
+          if (aiccExtensions.some((ext) => name.endsWith(ext))) {
+            return true;
+          }
+        }
+        return false;
+      }
+      /**
+       * Get a human-readable format name
+       */
+      getFormatDisplayName(format) {
+        const names = {
+          scorm12: "SCORM 1.2",
+          "scorm2004-3": "SCORM 2004 3rd Edition",
+          "scorm2004-4": "SCORM 2004 4th Edition",
+          cmi5: "cmi5",
+          xapi: "xAPI (Tin Can)",
+          aicc: "AICC",
+          unknown: "Unknown"
+        };
+        return names[format];
+      }
+    };
+  }
+});
+
+// src/detectors/index.ts
+var detectors_exports = {};
+__export(detectors_exports, {
+  FormatDetector: () => FormatDetector
+});
+var init_detectors = __esm({
+  "src/detectors/index.ts"() {
+    init_format_detector();
+  }
+});
+
+// src/templates/css-before.ts
+function generateCssBeforeLoader(options) {
+  const { remoteUrl, localPath, htmlClass, loadingClass } = options;
+  return `<!-- === PATCH-ADAMS: CSS BEFORE (blocking) === -->
+<style data-pa="css-before-critical">
+/* Critical: Hide content until ready */
+html.${htmlClass}.${loadingClass} body {
+  visibility: hidden !important;
+}
+</style>
+<script data-pa="css-before-loader">
+(function() {
+  'use strict';
+  var REMOTE_URL = "${remoteUrl}";
+  var LOCAL_PATH = "${localPath}";
+
+  function loadCSSSync(url) {
+    var link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = url;
+    link.setAttribute('data-pa', 'css-before');
+    document.head.appendChild(link);
+    return link;
+  }
+
+  // Try remote first
+  var link = loadCSSSync(REMOTE_URL);
+
+  link.onerror = function() {
+    console.warn('[Patch-Adams] CSS before failed to load from remote, using local fallback');
+    document.head.removeChild(link);
+    loadCSSSync(LOCAL_PATH);
+  };
+
+  link.onload = function() {
+    console.log('[Patch-Adams] CSS before loaded from remote:', REMOTE_URL);
+  };
+})();
+</script>`;
+}
+function buildCssBeforeOptions(config) {
+  return {
+    remoteUrl: `${config.remoteDomain}/${config.cssBefore.filename}`,
+    localPath: `${config.localFolders.css}/${config.cssBefore.filename}`,
+    htmlClass: config.htmlClass,
+    loadingClass: config.loadingClass
+  };
+}
+
+// src/templates/css-after.ts
+function generateCssAfterLoader(options) {
+  const { remoteUrl, localPath, timeout } = options;
+  return `<!-- === PATCH-ADAMS: CSS AFTER (async with fallback) === -->
+<script data-pa="css-after-loader">
+(function() {
+  'use strict';
+  var REMOTE_URL = "${remoteUrl}";
+  var LOCAL_PATH = "${localPath}";
+  var TIMEOUT = ${timeout};
+
+  function loadCSS(url, onSuccess, onError) {
+    var link = document.createElement('link');
+    link.rel = 'stylesheet';
+    link.href = url;
+    link.setAttribute('data-pa', 'css-after');
+
+    link.onload = function() {
+      if (onSuccess) onSuccess();
+    };
+
+    link.onerror = function() {
+      if (onError) onError();
+    };
+
+    document.head.appendChild(link);
+    return link;
+  }
+
+  function loadCSSWithFallback() {
+    var loaded = false;
+    var timeoutId;
+
+    // Try remote first
+    var remoteLink = loadCSS(
+      REMOTE_URL,
+      function() {
+        if (loaded) return;
+        loaded = true;
+        clearTimeout(timeoutId);
+        console.log('[Patch-Adams] CSS after loaded from remote:', REMOTE_URL);
+      },
+      function() {
+        if (loaded) return;
+        loaded = true;
+        clearTimeout(timeoutId);
+        loadLocalFallback();
+      }
+    );
+
+    // Timeout fallback
+    timeoutId = setTimeout(function() {
+      if (loaded) return;
+      loaded = true;
+      console.warn('[Patch-Adams] CSS after timed out, using local fallback');
+      if (remoteLink.parentNode) {
+        document.head.removeChild(remoteLink);
+      }
+      loadLocalFallback();
+    }, TIMEOUT);
+  }
+
+  function loadLocalFallback() {
+    loadCSS(
+      LOCAL_PATH,
+      function() {
+        console.log('[Patch-Adams] CSS after loaded from local fallback:', LOCAL_PATH);
+      },
+      function() {
+        console.error('[Patch-Adams] CSS after failed to load from both remote and local');
+      }
+    );
+  }
+
+  // Execute immediately
+  loadCSSWithFallback();
+})();
+</script>`;
+}
+function buildCssAfterOptions(config) {
+  return {
+    remoteUrl: `${config.remoteDomain}/${config.cssAfter.filename}`,
+    localPath: `${config.localFolders.css}/${config.cssAfter.filename}`,
+    timeout: config.cssAfter.timeout
+  };
+}
+
+// src/templates/js-before.ts
+function generateJsBeforeLoader(options) {
+  const { remoteUrl, localPath, htmlClass, loadingClass } = options;
+  return `<!-- === PATCH-ADAMS: JS BEFORE (blocking) === -->
+<script data-pa="js-before-loader">
+(function() {
+  'use strict';
+  var REMOTE_URL = "${remoteUrl}";
+  var LOCAL_PATH = "${localPath}";
+
+  // Initialize Patch-Adams global namespace
+  window.PatchAdams = window.PatchAdams || {
+    version: '1.0.0',
+    htmlClass: '${htmlClass}',
+    loadingClass: '${loadingClass}',
+    loaded: {
+      cssBefore: false,
+      cssAfter: false,
+      jsBefore: false,
+      jsAfter: false
+    }
+  };
+
+  function loadJSSync(url) {
+    var script = document.createElement('script');
+    script.src = url;
+    script.setAttribute('data-pa', 'js-before');
+    // Note: For truly blocking behavior, we use document.write
+    // but that's fragile. Instead we'll handle errors gracefully.
+    document.head.appendChild(script);
+    return script;
+  }
+
+  // Try remote first
+  var script = loadJSSync(REMOTE_URL);
+
+  script.onerror = function() {
+    console.warn('[Patch-Adams] JS before failed to load from remote, using local fallback');
+    document.head.removeChild(script);
+    var fallback = loadJSSync(LOCAL_PATH);
+    fallback.onload = function() {
+      window.PatchAdams.loaded.jsBefore = true;
+      console.log('[Patch-Adams] JS before loaded from local fallback:', LOCAL_PATH);
+    };
+    fallback.onerror = function() {
+      console.error('[Patch-Adams] JS before failed to load from both remote and local');
+    };
+  };
+
+  script.onload = function() {
+    window.PatchAdams.loaded.jsBefore = true;
+    console.log('[Patch-Adams] JS before loaded from remote:', REMOTE_URL);
+  };
+})();
+</script>`;
+}
+function buildJsBeforeOptions(config) {
+  return {
+    remoteUrl: `${config.remoteDomain}/${config.jsBefore.filename}`,
+    localPath: `${config.localFolders.js}/${config.jsBefore.filename}`,
+    htmlClass: config.htmlClass,
+    loadingClass: config.loadingClass
+  };
+}
+
+// src/templates/js-after.ts
+function generateJsAfterLoader(options) {
+  const { remoteUrl, localPath, timeout, loadingClass } = options;
+  return `<!-- === PATCH-ADAMS: JS AFTER (async with fallback) === -->
+<script data-pa="js-after-loader">
+(function() {
+  'use strict';
+  var REMOTE_URL = "${remoteUrl}";
+  var LOCAL_PATH = "${localPath}";
+  var TIMEOUT = ${timeout};
+  var LOADING_CLASS = "${loadingClass}";
+
+  function loadJS(url, onSuccess, onError) {
+    var script = document.createElement('script');
+    script.src = url;
+    script.async = true;
+    script.setAttribute('data-pa', 'js-after');
+
+    script.onload = function() {
+      if (onSuccess) onSuccess();
+    };
+
+    script.onerror = function() {
+      if (onError) onError();
+    };
+
+    document.body.appendChild(script);
+    return script;
+  }
+
+  function removeLoadingClass() {
+    document.documentElement.classList.remove(LOADING_CLASS);
+    if (window.PatchAdams) {
+      window.PatchAdams.loaded.jsAfter = true;
+    }
+    console.log('[Patch-Adams] Loading complete, content revealed');
+  }
+
+  function loadJSWithFallback() {
+    var loaded = false;
+    var timeoutId;
+
+    // Try remote first
+    var remoteScript = loadJS(
+      REMOTE_URL,
+      function() {
+        if (loaded) return;
+        loaded = true;
+        clearTimeout(timeoutId);
+        console.log('[Patch-Adams] JS after loaded from remote:', REMOTE_URL);
+        // Give the script a moment to execute, then remove loading class
+        setTimeout(removeLoadingClass, 50);
+      },
+      function() {
+        if (loaded) return;
+        loaded = true;
+        clearTimeout(timeoutId);
+        loadLocalFallback();
+      }
+    );
+
+    // Timeout fallback
+    timeoutId = setTimeout(function() {
+      if (loaded) return;
+      loaded = true;
+      console.warn('[Patch-Adams] JS after timed out, using local fallback');
+      if (remoteScript.parentNode) {
+        document.body.removeChild(remoteScript);
+      }
+      loadLocalFallback();
+    }, TIMEOUT);
+  }
+
+  function loadLocalFallback() {
+    loadJS(
+      LOCAL_PATH,
+      function() {
+        console.log('[Patch-Adams] JS after loaded from local fallback:', LOCAL_PATH);
+        setTimeout(removeLoadingClass, 50);
+      },
+      function() {
+        console.error('[Patch-Adams] JS after failed to load from both remote and local');
+        // Still remove loading class so content is visible even if JS fails
+        removeLoadingClass();
+      }
+    );
+  }
+
+  // Execute after DOM is ready to ensure Rise has loaded
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', function() {
+      // Small delay to ensure Rise has initialized
+      setTimeout(loadJSWithFallback, 100);
+    });
+  } else {
+    // DOM is already ready
+    setTimeout(loadJSWithFallback, 100);
+  }
+})();
+</script>`;
+}
+function buildJsAfterOptions(config) {
+  return {
+    remoteUrl: `${config.remoteDomain}/${config.jsAfter.filename}`,
+    localPath: `${config.localFolders.js}/${config.jsAfter.filename}`,
+    timeout: config.jsAfter.timeout,
+    loadingClass: config.loadingClass
+  };
+}
+
+// src/patcher/html-injector.ts
+var HtmlInjector = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Inject all loaders into HTML
+   */
+  inject(html) {
+    let result = html;
+    result = this.addHtmlClasses(result);
+    if (this.config.cssBefore.enabled) {
+      result = this.injectCssBefore(result);
+    }
+    if (this.config.jsBefore.enabled) {
+      result = this.injectJsBefore(result);
+    }
+    if (this.config.cssAfter.enabled) {
+      result = this.injectCssAfter(result);
+    }
+    if (this.config.jsAfter.enabled) {
+      result = this.injectJsAfter(result);
+    }
+    return result;
+  }
+  /**
+   * Add pa-patched and pa-loading classes to <html> tag
+   */
+  addHtmlClasses(html) {
+    const { htmlClass, loadingClass } = this.config;
+    const classes = `${htmlClass} ${loadingClass}`;
+    const htmlTagPattern = /<html([^>]*)>/i;
+    const match = html.match(htmlTagPattern);
+    if (!match) {
+      return html;
+    }
+    const attributes = match[1];
+    if (/class\s*=\s*["'][^"']*["']/i.test(attributes)) {
+      return html.replace(
+        htmlTagPattern,
+        (_match, attrs) => {
+          const newAttrs = attrs.replace(
+            /class\s*=\s*["']([^"']*)["']/i,
+            (_fullMatch, existingClasses) => `class="${existingClasses} ${classes}"`
+          );
+          return `<html${newAttrs}>`;
+        }
+      );
+    } else {
+      return html.replace(htmlTagPattern, `<html${attributes} class="${classes}">`);
+    }
+  }
+  /**
+   * Inject CSS Before loader at start of <head>
+   */
+  injectCssBefore(html) {
+    const options = buildCssBeforeOptions(this.config);
+    const loader = generateCssBeforeLoader(options);
+    return html.replace(/<head([^>]*)>/i, `<head$1>
+${loader}`);
+  }
+  /**
+   * Inject JS Before loader at start of <head> (after CSS Before if present)
+   */
+  injectJsBefore(html) {
+    const options = buildJsBeforeOptions(this.config);
+    const loader = generateJsBeforeLoader(options);
+    const cssBeforeMarker = "<!-- === PATCH-ADAMS: CSS BEFORE";
+    if (html.includes(cssBeforeMarker)) {
+      const cssBeforeEndPattern = /<\/script>\s*(?=\n|<)/;
+      const cssBeforeStart = html.indexOf(cssBeforeMarker);
+      const afterCssBefore = html.substring(cssBeforeStart);
+      const endMatch = afterCssBefore.match(cssBeforeEndPattern);
+      if (endMatch && endMatch.index !== void 0) {
+        const insertPos = cssBeforeStart + endMatch.index + endMatch[0].length;
+        return html.slice(0, insertPos) + "\n" + loader + html.slice(insertPos);
+      }
+    }
+    return html.replace(/<head([^>]*)>/i, `<head$1>
+${loader}`);
+  }
+  /**
+   * Inject CSS After loader at end of <head>
+   */
+  injectCssAfter(html) {
+    const options = buildCssAfterOptions(this.config);
+    const loader = generateCssAfterLoader(options);
+    return html.replace(/<\/head>/i, `${loader}
+</head>`);
+  }
+  /**
+   * Inject JS After loader at end of <body> (after __loadEntry)
+   */
+  injectJsAfter(html) {
+    const options = buildJsAfterOptions(this.config);
+    const loader = generateJsAfterLoader(options);
+    const loadEntryPattern = /(<script>__loadEntry\(\)<\/script>)/i;
+    if (loadEntryPattern.test(html)) {
+      return html.replace(loadEntryPattern, `$1
+${loader}`);
+    }
+    return html.replace(/<\/body>/i, `${loader}
+</body>`);
+  }
+};
+var ManifestUpdater = class {
+  config;
+  parser;
+  builder;
+  constructor(config) {
+    this.config = config;
+    this.parser = new fastXmlParser.XMLParser({
+      ignoreAttributes: false,
+      attributeNamePrefix: "@_",
+      preserveOrder: false,
+      parseAttributeValue: false,
+      trimValues: true
+    });
+    this.builder = new fastXmlParser.XMLBuilder({
+      ignoreAttributes: false,
+      attributeNamePrefix: "@_",
+      format: true,
+      indentBy: "  ",
+      suppressEmptyNode: true
+    });
+  }
+  /**
+   * Update manifest files based on package format
+   */
+  update(zip, format, paths) {
+    const modified = [];
+    switch (format) {
+      case "scorm12":
+      case "scorm2004-3":
+      case "scorm2004-4":
+        modified.push(...this.updateImsManifest(zip, paths));
+        break;
+      case "cmi5":
+        modified.push(...this.updateImsManifest(zip, paths));
+        break;
+      case "xapi":
+        break;
+      case "aicc":
+        const aiccManifest = zip.getEntry("imsmanifest.xml");
+        if (aiccManifest) {
+          modified.push(...this.updateImsManifest(zip, paths));
+        }
+        break;
+    }
+    return modified;
+  }
+  /**
+   * Update imsmanifest.xml to include new file references
+   */
+  updateImsManifest(zip, paths) {
+    const entry = zip.getEntry("imsmanifest.xml");
+    if (!entry) {
+      return [];
+    }
+    try {
+      const xmlContent = entry.getData().toString("utf-8");
+      const parsed = this.parser.parse(xmlContent);
+      this.addFilesToManifest(parsed, paths);
+      const xmlDeclaration = this.extractXmlDeclaration(xmlContent);
+      const updatedXml = xmlDeclaration + this.builder.build(parsed);
+      zip.updateFile("imsmanifest.xml", Buffer.from(updatedXml, "utf-8"));
+      return ["imsmanifest.xml"];
+    } catch (error) {
+      console.error("[Patch-Adams] Failed to update imsmanifest.xml:", error);
+      return [];
+    }
+  }
+  /**
+   * Extract XML declaration from original content
+   */
+  extractXmlDeclaration(xml) {
+    const match = xml.match(/<\?xml[^?]*\?>/);
+    return match ? match[0] + "\n" : '<?xml version="1.0" encoding="UTF-8"?>\n';
+  }
+  /**
+   * Add file entries to the manifest
+   */
+  addFilesToManifest(parsed, paths) {
+    const manifest = parsed.manifest;
+    if (!manifest) return;
+    const resources = manifest.resources;
+    if (!resources) return;
+    let resource = resources.resource;
+    if (!resource) return;
+    if (Array.isArray(resource)) {
+      resource = resource[0];
+    }
+    if (!resource.file) {
+      resource.file = [];
+    }
+    let files = resource.file;
+    if (!Array.isArray(files)) {
+      files = [files];
+      resource.file = files;
+    }
+    const filesToAdd = [
+      paths.cssBefore,
+      paths.cssAfter,
+      paths.jsBefore,
+      paths.jsAfter
+    ].filter(Boolean);
+    for (const filePath of filesToAdd) {
+      const exists = files.some((f) => f["@_href"] === filePath);
+      if (!exists) {
+        files.push({ "@_href": filePath });
+      }
+    }
+  }
+  /**
+   * Get the file paths that will be added to the package
+   */
+  getFilePaths() {
+    const paths = {};
+    if (this.config.cssBefore.enabled) {
+      paths.cssBefore = `scormcontent/${this.config.localFolders.css}/${this.config.cssBefore.filename}`;
+    }
+    if (this.config.cssAfter.enabled) {
+      paths.cssAfter = `scormcontent/${this.config.localFolders.css}/${this.config.cssAfter.filename}`;
+    }
+    if (this.config.jsBefore.enabled) {
+      paths.jsBefore = `scormcontent/${this.config.localFolders.js}/${this.config.jsBefore.filename}`;
+    }
+    if (this.config.jsAfter.enabled) {
+      paths.jsAfter = `scormcontent/${this.config.localFolders.js}/${this.config.jsAfter.filename}`;
+    }
+    return paths;
+  }
+};
+
+// src/patcher/index.ts
+init_format_detector();
+var DEFAULT_CSS_BEFORE = `/* Patch-Adams: CSS Before (blocking)
+ * This file loads at the start of <head> and blocks rendering.
+ * Use it to hide content and prevent flash of unstyled content.
+ *
+ * Example:
+ * html.pa-patched.pa-loading body {
+ *   visibility: hidden !important;
+ * }
+ */
+`;
+var DEFAULT_CSS_AFTER = `/* Patch-Adams: CSS After (async)
+ * This file loads at the end of <head> with remote fallback.
+ * Use it for style overrides that take precedence over Rise styles.
+ *
+ * Example:
+ * html.pa-patched .blocks-text {
+ *   font-family: 'Your Font', sans-serif !important;
+ * }
+ */
+`;
+var DEFAULT_JS_BEFORE = `// Patch-Adams: JS Before (blocking)
+// This file loads at the start of <head> and blocks rendering.
+// Use it for setup, API interception, and preparing globals.
+//
+// Example:
+// window.PatchAdams.customConfig = {
+//   theme: 'dark',
+//   analytics: true
+// };
+
+console.log('[Patch-Adams] JS Before loaded');
+`;
+var DEFAULT_JS_AFTER = `// Patch-Adams: JS After (async)
+// This file loads at the end of <body> with remote fallback.
+// Use it for DOM manipulation after Rise has initialized.
+//
+// IMPORTANT: This script should NOT remove the loading class.
+// The loader script handles that automatically after this script loads.
+//
+// Example:
+// document.querySelectorAll('.blocks-text').forEach(function(el) {
+//   // Your modifications here
+// });
+
+console.log('[Patch-Adams] JS After loaded');
+`;
+var Patcher = class {
+  config;
+  htmlInjector;
+  manifestUpdater;
+  formatDetector;
+  constructor(config) {
+    this.config = config;
+    this.htmlInjector = new HtmlInjector(config);
+    this.manifestUpdater = new ManifestUpdater(config);
+    this.formatDetector = new FormatDetector();
+  }
+  /**
+   * Patch a Rise course ZIP file
+   * @param inputBuffer - Input ZIP file as Buffer
+   * @param options - Additional patching options
+   * @returns Patched ZIP file as Buffer and result details
+   */
+  async patch(inputBuffer, options = {}) {
+    const result = {
+      success: false,
+      format: "unknown",
+      formatDisplayName: "Unknown",
+      filesModified: [],
+      filesAdded: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const zip = new AdmZip__default.default(inputBuffer);
+      result.format = this.formatDetector.detect(zip);
+      result.formatDisplayName = this.formatDetector.getFormatDisplayName(result.format);
+      if (result.format === "unknown") {
+        result.warnings.push("Could not determine package format, proceeding anyway");
+      }
+      const indexHtmlEntry = zip.getEntry("scormcontent/index.html");
+      if (!indexHtmlEntry) {
+        throw new Error("Could not find scormcontent/index.html in package. Is this a valid Rise export?");
+      }
+      const originalHtml = indexHtmlEntry.getData().toString("utf-8");
+      const patchedHtml = this.htmlInjector.inject(originalHtml);
+      zip.updateFile("scormcontent/index.html", Buffer.from(patchedHtml, "utf-8"));
+      result.filesModified.push("scormcontent/index.html");
+      const addedFiles = this.addFallbackFiles(zip, options);
+      result.filesAdded.push(...addedFiles);
+      if (this.config.updateManifests) {
+        const manifestPaths = this.manifestUpdater.getFilePaths();
+        const modifiedManifests = this.manifestUpdater.update(zip, result.format, manifestPaths);
+        result.filesModified.push(...modifiedManifests);
+      }
+      result.success = true;
+      return { buffer: zip.toBuffer(), result };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      result.errors.push(message);
+      throw error;
+    }
+  }
+  /**
+   * Add local fallback files to the ZIP
+   */
+  addFallbackFiles(zip, options) {
+    const added = [];
+    const cssFolder = `scormcontent/${this.config.localFolders.css}`;
+    const jsFolder = `scormcontent/${this.config.localFolders.js}`;
+    if (this.config.cssBefore.enabled) {
+      const path = `${cssFolder}/${this.config.cssBefore.filename}`;
+      const content = options.cssBeforeContent ?? DEFAULT_CSS_BEFORE;
+      zip.addFile(path, Buffer.from(content, "utf-8"));
+      added.push(path);
+    }
+    if (this.config.cssAfter.enabled) {
+      const path = `${cssFolder}/${this.config.cssAfter.filename}`;
+      const content = options.cssAfterContent ?? DEFAULT_CSS_AFTER;
+      zip.addFile(path, Buffer.from(content, "utf-8"));
+      added.push(path);
+    }
+    if (this.config.jsBefore.enabled) {
+      const path = `${jsFolder}/${this.config.jsBefore.filename}`;
+      const content = options.jsBeforeContent ?? DEFAULT_JS_BEFORE;
+      zip.addFile(path, Buffer.from(content, "utf-8"));
+      added.push(path);
+    }
+    if (this.config.jsAfter.enabled) {
+      const path = `${jsFolder}/${this.config.jsAfter.filename}`;
+      const content = options.jsAfterContent ?? DEFAULT_JS_AFTER;
+      zip.addFile(path, Buffer.from(content, "utf-8"));
+      added.push(path);
+    }
+    return added;
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Convenience method to patch a buffer and return only the patched buffer.
+   * Used by package-uploader integration.
+   * @param buffer - Input ZIP file as Buffer
+   * @returns Patched ZIP file as Buffer
+   */
+  async patchBuffer(buffer) {
+    const { buffer: patchedBuffer } = await this.patch(buffer);
+    return patchedBuffer;
+  }
+};
+var BlockingAssetConfigSchema = zod.z.object({
+  /** Filename for the asset */
+  filename: zod.z.string().min(1),
+  /** Whether this asset is enabled */
+  enabled: zod.z.boolean().default(true)
+});
+var AsyncAssetConfigSchema = zod.z.object({
+  /** Filename for the asset */
+  filename: zod.z.string().min(1),
+  /** Whether this asset is enabled */
+  enabled: zod.z.boolean().default(true),
+  /** Timeout in milliseconds for remote loading before falling back to local */
+  timeout: zod.z.number().min(1e3).max(3e4).default(5e3)
+});
+var LocalFoldersConfigSchema = zod.z.object({
+  /** Folder name for CSS files within scormcontent */
+  css: zod.z.string().default("css"),
+  /** Folder name for JS files within scormcontent */
+  js: zod.z.string().default("js")
+});
+var PatchAdamsConfigSchema = zod.z.object({
+  /** Remote domain for assets (e.g., "https://cdn.example.com/rise-overrides") */
+  remoteDomain: zod.z.string().url(),
+  /** CSS class added to <html> tag for specificity (default: "pa-patched") */
+  htmlClass: zod.z.string().default("pa-patched"),
+  /** CSS class added during loading, removed when ready (default: "pa-loading") */
+  loadingClass: zod.z.string().default("pa-loading"),
+  /** CSS loaded at start of <head> - blocking, prevents FOUC */
+  cssBefore: BlockingAssetConfigSchema.default({
+    filename: "before.css",
+    enabled: true
+  }),
+  /** CSS loaded at end of <head> - async with fallback, for overrides */
+  cssAfter: AsyncAssetConfigSchema.default({
+    filename: "after.css",
+    enabled: true,
+    timeout: 5e3
+  }),
+  /** JS loaded at start of <head> - blocking, for setup/interception */
+  jsBefore: BlockingAssetConfigSchema.default({
+    filename: "before.js",
+    enabled: true
+  }),
+  /** JS loaded at end of <body> - async with fallback, removes loading class */
+  jsAfter: AsyncAssetConfigSchema.default({
+    filename: "after.js",
+    enabled: true,
+    timeout: 5e3
+  }),
+  /** Local folder names for fallback files */
+  localFolders: LocalFoldersConfigSchema.default({}),
+  /** Whether to update manifest files (imsmanifest.xml, etc.) for SCORM compliance */
+  updateManifests: zod.z.boolean().default(true)
+});
+
+// src/config/defaults.ts
+var defaultConfig = {
+  remoteDomain: "https://cdn.example.com/rise-overrides",
+  htmlClass: "pa-patched",
+  loadingClass: "pa-loading",
+  cssBefore: {
+    filename: "before.css",
+    enabled: true
+  },
+  cssAfter: {
+    filename: "after.css",
+    enabled: true,
+    timeout: 5e3
+  },
+  jsBefore: {
+    filename: "before.js",
+    enabled: true
+  },
+  jsAfter: {
+    filename: "after.js",
+    enabled: true,
+    timeout: 5e3
+  },
+  localFolders: {
+    css: "css",
+    js: "js"
+  },
+  updateManifests: true
+};
+async function loadConfig(configPath) {
+  const absolutePath = path.resolve(configPath);
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Configuration file not found: ${absolutePath}`);
+  }
+  const ext = path.extname(absolutePath).toLowerCase();
+  let rawConfig;
+  if (ext === ".json") {
+    const content = fs.readFileSync(absolutePath, "utf-8");
+    rawConfig = JSON.parse(content);
+  } else if (ext === ".ts" || ext === ".js" || ext === ".mjs") {
+    const fileUrl = url.pathToFileURL(absolutePath).href;
+    const module = await import(fileUrl);
+    rawConfig = module.default ?? module;
+  } else {
+    throw new Error(`Unsupported config file extension: ${ext}. Use .ts, .js, .mjs, or .json`);
+  }
+  const validated = PatchAdamsConfigSchema.parse(rawConfig);
+  return validated;
+}
+function mergeWithDefaults(partial) {
+  return PatchAdamsConfigSchema.parse({
+    ...defaultConfig,
+    ...partial
+  });
+}
+function generateConfigTemplate() {
+  return `import type { PatchAdamsConfig } from '@patch-adams/core';
+
+const config: PatchAdamsConfig = {
+  // Remote domain where your CSS/JS files are hosted
+  remoteDomain: 'https://cdn.example.com/rise-overrides',
+
+  // HTML classes for specificity and loading state
+  htmlClass: 'pa-patched',      // Always present on <html>
+  loadingClass: 'pa-loading',   // Removed when assets are loaded
+
+  // CSS loaded at start of <head> - BLOCKING
+  // Use this to hide content and prevent flash of unstyled content
+  cssBefore: {
+    filename: 'before.css',
+    enabled: true,
+  },
+
+  // CSS loaded at end of <head> - ASYNC with fallback
+  // Use this for style overrides
+  cssAfter: {
+    filename: 'after.css',
+    enabled: true,
+    timeout: 5000, // ms before falling back to local
+  },
+
+  // JS loaded at start of <head> - BLOCKING
+  // Use this for setup, API interception, globals
+  jsBefore: {
+    filename: 'before.js',
+    enabled: true,
+  },
+
+  // JS loaded at end of <body> - ASYNC with fallback
+  // Use this for DOM manipulation after Rise loads
+  // This should remove the loadingClass when done
+  jsAfter: {
+    filename: 'after.js',
+    enabled: true,
+    timeout: 5000, // ms before falling back to local
+  },
+
+  // Folder names for local fallback files within scormcontent/
+  localFolders: {
+    css: 'css',
+    js: 'js',
+  },
+
+  // Update manifest files for SCORM compliance
+  updateManifests: true,
+};
+
+export default config;
+`;
+}
+
+// src/cli.ts
+var program = new commander.Command();
+program.name("patch-adams").description("Patch Rise course packages to inject remote CSS/JS with local fallback").version("1.0.0");
+program.command("patch <input>").description("Patch a Rise course ZIP file").option("-o, --output <path>", "Output file path (default: <input>-patched.zip)").option("-c, --config <path>", "Configuration file path (default: ./patch-adams.config.ts)").option("--css-before <path>", 'Local CSS file for "before" fallback').option("--css-after <path>", 'Local CSS file for "after" fallback').option("--js-before <path>", 'Local JS file for "before" fallback').option("--js-after <path>", 'Local JS file for "after" fallback').option("--no-manifest", "Skip updating manifest files").action(async (input, options) => {
+  const spinner = ora__default.default("Loading configuration...").start();
+  try {
+    let config;
+    const configPath = options.config || "./patch-adams.config.ts";
+    if (fs.existsSync(path.resolve(configPath))) {
+      config = await loadConfig(configPath);
+      spinner.text = "Configuration loaded";
+    } else {
+      spinner.text = "No config file found, using defaults";
+      config = mergeWithDefaults({});
+    }
+    if (options.manifest === false) {
+      config = { ...config, updateManifests: false };
+    }
+    const validatedConfig = PatchAdamsConfigSchema.parse(config);
+    spinner.text = "Reading input file...";
+    const inputPath = path.resolve(input);
+    if (!fs.existsSync(inputPath)) {
+      throw new Error(`Input file not found: ${inputPath}`);
+    }
+    const inputBuffer = fs.readFileSync(inputPath);
+    const patchOptions = {};
+    if (options.cssBefore) {
+      patchOptions.cssBeforeContent = fs.readFileSync(path.resolve(options.cssBefore), "utf-8");
+    }
+    if (options.cssAfter) {
+      patchOptions.cssAfterContent = fs.readFileSync(path.resolve(options.cssAfter), "utf-8");
+    }
+    if (options.jsBefore) {
+      patchOptions.jsBeforeContent = fs.readFileSync(path.resolve(options.jsBefore), "utf-8");
+    }
+    if (options.jsAfter) {
+      patchOptions.jsAfterContent = fs.readFileSync(path.resolve(options.jsAfter), "utf-8");
+    }
+    spinner.text = "Patching package...";
+    const patcher = new Patcher(validatedConfig);
+    const { buffer, result } = await patcher.patch(inputBuffer, patchOptions);
+    const outputPath = options.output || inputPath.replace(/\.zip$/i, "-patched.zip");
+    spinner.text = "Writing output file...";
+    fs.writeFileSync(outputPath, buffer);
+    spinner.succeed(chalk__default.default.green("Patching complete!"));
+    console.log("");
+    console.log(chalk__default.default.blue("Format detected:"), result.formatDisplayName);
+    console.log(chalk__default.default.blue("Remote domain:"), validatedConfig.remoteDomain);
+    console.log("");
+    if (result.filesModified.length > 0) {
+      console.log(chalk__default.default.blue("Files modified:"));
+      result.filesModified.forEach((f) => console.log(`  ${chalk__default.default.gray("\u2022")} ${f}`));
+    }
+    if (result.filesAdded.length > 0) {
+      console.log(chalk__default.default.blue("Files added:"));
+      result.filesAdded.forEach((f) => console.log(`  ${chalk__default.default.gray("\u2022")} ${f}`));
+    }
+    if (result.warnings.length > 0) {
+      console.log("");
+      console.log(chalk__default.default.yellow("Warnings:"));
+      result.warnings.forEach((w) => console.log(`  ${chalk__default.default.yellow("!")} ${w}`));
+    }
+    console.log("");
+    console.log(chalk__default.default.green("Output:"), outputPath);
+  } catch (error) {
+    spinner.fail(chalk__default.default.red("Patching failed"));
+    console.error(
+      chalk__default.default.red(error instanceof Error ? error.message : String(error))
+    );
+    process.exit(1);
+  }
+});
+program.command("init").description("Create a sample configuration file").option("-o, --output <path>", "Output path (default: ./patch-adams.config.ts)").action((options) => {
+  const outputPath = path.resolve(options.output || "./patch-adams.config.ts");
+  if (fs.existsSync(outputPath)) {
+    console.log(
+      chalk__default.default.yellow(`Configuration file already exists: ${outputPath}`)
+    );
+    console.log(chalk__default.default.yellow("Use --output to specify a different path"));
+    process.exit(1);
+  }
+  const template = generateConfigTemplate();
+  fs.writeFileSync(outputPath, template);
+  console.log(chalk__default.default.green(`Configuration file created: ${outputPath}`));
+  console.log("");
+  console.log("Next steps:");
+  console.log(`  1. Edit ${chalk__default.default.cyan(path.basename(outputPath))} to configure your settings`);
+  console.log(`  2. Run ${chalk__default.default.cyan("patch-adams patch <input.zip>")} to patch a course`);
+});
+program.command("info <input>").description("Display information about a Rise course package").action(async (input) => {
+  const spinner = ora__default.default("Analyzing package...").start();
+  try {
+    const inputPath = path.resolve(input);
+    if (!fs.existsSync(inputPath)) {
+      throw new Error(`Input file not found: ${inputPath}`);
+    }
+    const inputBuffer = fs.readFileSync(inputPath);
+    const AdmZip2 = (await import('adm-zip')).default;
+    const zip = new AdmZip2(inputBuffer);
+    const { FormatDetector: FormatDetector2 } = await Promise.resolve().then(() => (init_detectors(), detectors_exports));
+    const detector = new FormatDetector2();
+    const format = detector.detect(zip);
+    const formatName = detector.getFormatDisplayName(format);
+    spinner.succeed("Package analyzed");
+    console.log("");
+    console.log(chalk__default.default.blue("File:"), inputPath);
+    console.log(chalk__default.default.blue("Format:"), formatName);
+    console.log("");
+    const keyFiles = [
+      "scormcontent/index.html",
+      "scormdriver/indexAPI.html",
+      "imsmanifest.xml",
+      "cmi5.xml",
+      "tincan.xml"
+    ];
+    console.log(chalk__default.default.blue("Key files:"));
+    for (const file of keyFiles) {
+      const exists = zip.getEntry(file) !== null;
+      const icon = exists ? chalk__default.default.green("\u2713") : chalk__default.default.gray("\u25CB");
+      console.log(`  ${icon} ${file}`);
+    }
+    const entries = zip.getEntries();
+    console.log("");
+    console.log(chalk__default.default.blue("Total files:"), entries.length);
+  } catch (error) {
+    spinner.fail(chalk__default.default.red("Analysis failed"));
+    console.error(
+      chalk__default.default.red(error instanceof Error ? error.message : String(error))
+    );
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=cli.cjs.map
+//# sourceMappingURL=cli.cjs.map