epicshop 6.84.7 → 6.85.0

package/dist/cli.js

@@ -742,7 +742,7 @@ const cli = yargs(args)
         .positional('subcommand', {
         describe: 'Admin subcommand',
         type: 'string',
-        choices: ['launch-readiness'],
+        choices: ['launch-readiness', 'set-videos'],
     })
         .option('workshop-dir', {
         alias: 'w',
@@ -765,7 +765,14 @@ const cli = yargs(args)
         description: 'Skip checking that EpicVideo urls return 200 to HEAD (network required)',
         default: false,
     })
-        .example('$0 admin launch-readiness', 'Check workshop launch readiness (hidden command)');
+        .option('dry-run', {
+        type: 'boolean',
+        description: 'Preview set-videos changes without writing files (set-videos only)',
+        default: false,
+    })
+        .example('$0 admin launch-readiness', 'Check workshop launch readiness (hidden command)')
+        .example('$0 admin set-videos', 'Set top EpicVideo embeds from product lesson order (hidden command)')
+        .example('$0 admin set-videos --dry-run', 'Preview top EpicVideo changes without writing files');
 }, async (argv) => {
     const { findWorkshopRoot } = await import("./commands/workshops.js");
     const workshopRoot = await findWorkshopRoot(resolveWorkshopContextCwd(argv.workshopDir));
@@ -789,6 +796,16 @@ const cli = yargs(args)
                     process.exit(1);
                 break;
             }
+            case 'set-videos': {
+                const { setVideos } = await import("./commands/admin.js");
+                const result = await setVideos({
+                    silent: argv.silent,
+                    dryRun: argv.dryRun,
+                });
+                if (!result.success)
+                    process.exit(1);
+                break;
+            }
             default: {
                 console.error(chalk.red(`❌ Unknown admin subcommand: ${argv.subcommand}`));
                 process.exit(1);

package/dist/commands/admin/launch-readiness.js

@@ -1,14 +1,10 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { compileMdx } from '@epic-web/workshop-utils/compile-mdx.server';
-import { getAuthInfo } from '@epic-web/workshop-utils/db.server';
 import { getErrorMessage } from '@epic-web/workshop-utils/utils';
 import chalk from 'chalk';
 import { pathExists } from "../../utils/filesystem.js";
-function stripEpicAiSlugSuffix(value) {
-    // EpicAI embeds sometimes include a `~...` suffix in the slug segment.
-    return value.replace(/~[^ ]*$/, '');
-}
+import { collectStepDirectories, formatProductLessonUrl, fetchRemoteWorkshopLessons, isDirectory, resolveMdxFile, stripEpicAiSlugSuffix, } from "./workshop-content-utils.js";
 function normalizeHost(host) {
     return host.toLowerCase().replace(/^www\./, '');
 }
@@ -59,10 +55,6 @@ function parseEpicLessonSlugFromEmbedUrl(urlString) {
         return parseSegments(segments);
     }
 }
-function formatProductLessonUrl({ productHost, productSlug, lessonSlug, }) {
-    // The product site will typically redirect to a section-specific path when needed.
-    return `https://${productHost}/workshops/${productSlug}/${lessonSlug}`;
-}
 function formatIssue(issue, workshopRoot) {
     const icon = issue.level === 'error' ? chalk.red('❌') : chalk.yellow('⚠️ ');
     const filePart = issue.file
@@ -70,20 +62,6 @@ function formatIssue(issue, workshopRoot) {
         : '';
     return `${icon} ${issue.message}${filePart}`;
 }
-async function isDirectory(targetPath) {
-    try {
-        return (await fs.stat(targetPath)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-async function resolveMdxFile(dir, baseName) {
-    const mdx = path.join(dir, `${baseName}.mdx`);
-    if (await pathExists(mdx))
-        return mdx;
-    return null;
-}
 async function buildExpectedFiles({ workshopRoot, exerciseDirName, }) {
     const issues = [];
     const files = [];
@@ -142,29 +120,7 @@ async function buildExpectedFiles({ workshopRoot, exerciseDirName, }) {
         });
         return { files, contentFiles, issues };
     }
-    const stepDirRegex = /^(?<stepNumber>\d+)\.(?<type>problem|solution)(\..*)?$/;
-    const stepsByNumber = new Map();
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        const match = stepDirRegex.exec(entry.name);
-        if (!match?.groups)
-            continue;
-        const stepNumber = Number(match.groups.stepNumber);
-        const type = match.groups.type;
-        if (!Number.isFinite(stepNumber) || stepNumber <= 0)
-            continue;
-        const current = stepsByNumber.get(stepNumber) ?? {
-            problems: [],
-            solutions: [],
-        };
-        const fullStepDir = path.join(exerciseRoot, entry.name);
-        if (type === 'problem')
-            current.problems.push(fullStepDir);
-        if (type === 'solution')
-            current.solutions.push(fullStepDir);
-        stepsByNumber.set(stepNumber, current);
-    }
+    const stepsByNumber = collectStepDirectories(entries, exerciseRoot);
     if (stepsByNumber.size === 0) {
         issues.push({
             level: 'warning',
@@ -253,96 +209,6 @@ async function buildExpectedFiles({ workshopRoot, exerciseDirName, }) {
     }
     return { files, contentFiles, issues };
 }
-async function fetchRemoteWorkshopLessonSlugs({ productHost, workshopSlug, }) {
-    const url = `https://${productHost}/api/workshops/${encodeURIComponent(workshopSlug)}`;
-    const fetchOnce = async (accessToken) => {
-        const timeout = AbortSignal.timeout(15_000);
-        const headers = {};
-        if (accessToken)
-            headers.authorization = `Bearer ${accessToken}`;
-        return fetch(url, { headers, signal: timeout });
-    };
-    let response = null;
-    try {
-        response = await fetchOnce();
-    }
-    catch (error) {
-        return {
-            status: 'error',
-            message: `Failed to fetch product workshop data: ${getErrorMessage(error)}`,
-        };
-    }
-    if (response.status === 401 || response.status === 403) {
-        const authInfo = await getAuthInfo({ productHost }).catch(() => null);
-        const accessToken = authInfo?.tokenSet?.access_token;
-        if (accessToken) {
-            try {
-                response = await fetchOnce(accessToken);
-            }
-            catch (error) {
-                return {
-                    status: 'error',
-                    message: `Failed to fetch product workshop data (after auth): ${getErrorMessage(error)}`,
-                };
-            }
-        }
-    }
-    if (!response.ok) {
-        const body = await response.text().catch(() => '');
-        const hint = response.status === 401 || response.status === 403
-            ? ` (try: npx epicshop auth login ${productHost.replace(/^www\./, '')})`
-            : response.status === 404
-                ? ` (check epicshop.product.host + epicshop.product.slug)`
-                : '';
-        return {
-            status: 'error',
-            message: `Product API request failed: ${response.status} ${response.statusText}${hint}${body ? `\n${body}` : ''}`,
-        };
-    }
-    let data;
-    try {
-        data = await response.json();
-    }
-    catch (error) {
-        return {
-            status: 'error',
-            message: `Product API response was not valid JSON: ${getErrorMessage(error)}`,
-        };
-    }
-    const resources = data?.resources;
-    if (!Array.isArray(resources)) {
-        return {
-            status: 'error',
-            message: `Product API response did not include an array "resources" field`,
-        };
-    }
-    const lessonSlugs = [];
-    for (const resource of resources) {
-        if (!resource || typeof resource !== 'object')
-            continue;
-        const r = resource;
-        if (r._type === 'lesson') {
-            const slug = r.slug;
-            if (typeof slug === 'string')
-                lessonSlugs.push(slug);
-            continue;
-        }
-        if (r._type === 'section') {
-            const lessons = r.lessons;
-            if (!Array.isArray(lessons))
-                continue;
-            for (const lesson of lessons) {
-                if (!lesson || typeof lesson !== 'object')
-                    continue;
-                const l = lesson;
-                const slug = l.slug;
-                if (typeof slug === 'string')
-                    lessonSlugs.push(slug);
-            }
-        }
-    }
-    return { status: 'success', lessonSlugs };
-}
 async function checkMinContentLength({ fullPath, minChars, }) {
     try {
         const raw = await fs.readFile(fullPath, 'utf8');
@@ -838,7 +704,7 @@ export async function launchReadiness(options = {}) {
                 }
                 localProductLessonSlugs.add(lessonSlug);
             }
-            const remote = await fetchRemoteWorkshopLessonSlugs({
+            const remote = await fetchRemoteWorkshopLessons({
                 productHost,
                 workshopSlug: productSlug,
             });
@@ -850,7 +716,21 @@ export async function launchReadiness(options = {}) {
                 });
             }
             else {
-                const remoteLessonSlugs = Array.from(new Set(remote.lessonSlugs.map(stripEpicAiSlugSuffix)));
+                const remoteLessons = remote.lessons
+                    .map((l) => ({
+                    slug: stripEpicAiSlugSuffix(l.slug),
+                    sectionSlug: l.sectionSlug
+                        ? stripEpicAiSlugSuffix(l.sectionSlug)
+                        : null,
+                }))
+                    .filter((l) => l.slug.trim().length > 0);
+                // Preserve the first sectionSlug seen for a given lesson slug.
+                const remoteLessonBySlug = new Map();
+                for (const l of remoteLessons) {
+                    if (!remoteLessonBySlug.has(l.slug))
+                        remoteLessonBySlug.set(l.slug, l);
+                }
+                const remoteLessonSlugs = [...remoteLessonBySlug.keys()];
                 if (remoteLessonSlugs.length === 0) {
                     issues.push({
                         level: 'error',
@@ -862,11 +742,15 @@ export async function launchReadiness(options = {}) {
                 if (missing.length) {
                     const formatted = missing
                         .sort()
-                        .map((slug) => `- ${slug}: ${formatProductLessonUrl({
-                        productHost,
-                        productSlug,
-                        lessonSlug: slug,
-                    })}`)
+                        .map((slug) => {
+                        const remoteLesson = remoteLessonBySlug.get(slug);
+                        return `- ${slug}: ${formatProductLessonUrl({
+                            productHost,
+                            productSlug,
+                            lessonSlug: slug,
+                            sectionSlug: remoteLesson?.sectionSlug ?? null,
+                        })}`;
+                    })
                         .join('\n');
                     issues.push({
                         level: 'error',

package/dist/commands/admin/set-videos.d.ts

@@ -0,0 +1,20 @@
+export type SetVideosOptions = {
+    /**
+     * Defaults to `process.env.EPICSHOP_CONTEXT_CWD ?? process.cwd()`.
+     * Primarily useful for tests.
+     */
+    workshopRoot?: string;
+    silent?: boolean;
+    dryRun?: boolean;
+};
+export type SetVideosResult = {
+    success: boolean;
+    message: string;
+    error?: Error;
+    inserted: number;
+    updated: number;
+    unchanged: number;
+    warnings: Array<string>;
+    dryRun: boolean;
+};
+export declare function setVideos(options?: SetVideosOptions): Promise<SetVideosResult>;

package/dist/commands/admin/set-videos.js

@@ -0,0 +1,462 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getErrorMessage } from '@epic-web/workshop-utils/utils';
+import chalk from 'chalk';
+import { collectStepDirectories, formatProductLessonUrl, fetchRemoteWorkshopLessons, isDirectory, resolveMdxFile, stripEpicAiSlugSuffix, } from "./workshop-content-utils.js";
+function createFailureResult(message, { dryRun = false } = {}) {
+    return {
+        success: false,
+        message,
+        error: new Error(message),
+        inserted: 0,
+        updated: 0,
+        unchanged: 0,
+        warnings: [],
+        dryRun,
+    };
+}
+async function collectOrderedVideoFiles({ workshopRoot, }) {
+    const files = [];
+    const errors = [];
+    const warnings = [];
+    const exercisesRoot = path.join(workshopRoot, 'exercises');
+    if (!(await isDirectory(exercisesRoot))) {
+        errors.push('Missing `exercises/` directory (required for a workshop)');
+        return { files, errors, warnings };
+    }
+    const workshopIntro = await resolveMdxFile(exercisesRoot, 'README');
+    if (!workshopIntro) {
+        errors.push('Missing workshop intro file `exercises/README.mdx`');
+    }
+    else {
+        files.push({
+            kind: 'workshop-intro',
+            fullPath: workshopIntro,
+            relativePath: path.relative(workshopRoot, workshopIntro),
+        });
+    }
+    const workshopWrapUp = await resolveMdxFile(exercisesRoot, 'FINISHED');
+    if (!workshopWrapUp) {
+        errors.push('Missing workshop wrap-up file `exercises/FINISHED.mdx`');
+    }
+    const exerciseEntries = await fs.readdir(exercisesRoot, {
+        withFileTypes: true,
+    });
+    const exerciseDirNames = exerciseEntries
+        .filter((e) => e.isDirectory() && /^\d+\./.test(e.name))
+        .map((e) => e.name)
+        .sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+    if (exerciseDirNames.length === 0) {
+        warnings.push('No exercise directories found (expected folders like "01.my-exercise" under exercises/)');
+    }
+    for (const exerciseDirName of exerciseDirNames) {
+        const exerciseRoot = path.join(exercisesRoot, exerciseDirName);
+        const exerciseNumberMatch = /^(\d+)\./.exec(exerciseDirName);
+        const exerciseNumber = exerciseNumberMatch
+            ? Number(exerciseNumberMatch[1])
+            : undefined;
+        const exerciseIntro = await resolveMdxFile(exerciseRoot, 'README');
+        if (!exerciseIntro) {
+            errors.push(`Missing exercise intro file (expected README.mdx): ${path.relative(workshopRoot, path.join(exerciseRoot, 'README.mdx'))}`);
+        }
+        else {
+            files.push({
+                kind: 'exercise-intro',
+                fullPath: exerciseIntro,
+                relativePath: path.relative(workshopRoot, exerciseIntro),
+                exerciseNumber,
+            });
+        }
+        let entries = [];
+        try {
+            entries = await fs.readdir(exerciseRoot, { withFileTypes: true });
+        }
+        catch (error) {
+            errors.push(`Failed to read exercise directory "${path.relative(workshopRoot, exerciseRoot)}": ${getErrorMessage(error)}`);
+            continue;
+        }
+        const stepsByNumber = collectStepDirectories(entries, exerciseRoot);
+        if (stepsByNumber.size === 0) {
+            warnings.push(`No step app directories found in "${path.relative(workshopRoot, exerciseRoot)}" (expected folders like "01.problem" and "01.solution")`);
+        }
+        for (const [stepNumber, dirs] of [...stepsByNumber.entries()].sort((a, b) => a[0] - b[0])) {
+            if (dirs.problems.length === 0) {
+                errors.push(`Missing problem app directory for step ${stepNumber} in ${path.relative(workshopRoot, exerciseRoot)}`);
+            }
+            if (dirs.solutions.length === 0) {
+                errors.push(`Missing solution app directory for step ${stepNumber} in ${path.relative(workshopRoot, exerciseRoot)}`);
+            }
+            if (dirs.problems.length > 1) {
+                warnings.push(`Multiple problem app directories found for step ${stepNumber} in ${path.relative(workshopRoot, exerciseRoot)}`);
+            }
+            if (dirs.solutions.length > 1) {
+                warnings.push(`Multiple solution app directories found for step ${stepNumber} in ${path.relative(workshopRoot, exerciseRoot)}`);
+            }
+            for (const problemDir of [...dirs.problems].sort((a, b) => a.localeCompare(b))) {
+                const problemReadme = await resolveMdxFile(problemDir, 'README');
+                if (!problemReadme) {
+                    errors.push(`Missing step problem README.mdx: ${path.relative(workshopRoot, path.join(problemDir, 'README.mdx'))}`);
+                    continue;
+                }
+                files.push({
+                    kind: 'step-problem',
+                    fullPath: problemReadme,
+                    relativePath: path.relative(workshopRoot, problemReadme),
+                    exerciseNumber,
+                    stepNumber,
+                });
+            }
+            for (const solutionDir of [...dirs.solutions].sort((a, b) => a.localeCompare(b))) {
+                const solutionReadme = await resolveMdxFile(solutionDir, 'README');
+                if (!solutionReadme) {
+                    errors.push(`Missing step solution README.mdx: ${path.relative(workshopRoot, path.join(solutionDir, 'README.mdx'))}`);
+                    continue;
+                }
+                files.push({
+                    kind: 'step-solution',
+                    fullPath: solutionReadme,
+                    relativePath: path.relative(workshopRoot, solutionReadme),
+                    exerciseNumber,
+                    stepNumber,
+                });
+            }
+        }
+        const exerciseSummary = await resolveMdxFile(exerciseRoot, 'FINISHED');
+        if (!exerciseSummary) {
+            errors.push(`Missing exercise summary file (expected FINISHED.mdx): ${path.relative(workshopRoot, path.join(exerciseRoot, 'FINISHED.mdx'))}`);
+        }
+        else {
+            files.push({
+                kind: 'exercise-summary',
+                fullPath: exerciseSummary,
+                relativePath: path.relative(workshopRoot, exerciseSummary),
+                exerciseNumber,
+            });
+        }
+    }
+    if (workshopWrapUp) {
+        files.push({
+            kind: 'workshop-wrap-up',
+            fullPath: workshopWrapUp,
+            relativePath: path.relative(workshopRoot, workshopWrapUp),
+        });
+    }
+    return { files, errors, warnings };
+}
+function setEpicVideoUrl({ epicVideoBlock, url, }) {
+    const openingTagMatch = epicVideoBlock.match(/<EpicVideo\b[\s\S]*?>/);
+    if (!openingTagMatch) {
+        return epicVideoBlock;
+    }
+    const openingTag = openingTagMatch[0];
+    const urlAttrMatch = openingTag.match(/\burl\s*=\s*("([^"]*)"|'([^']*)')/);
+    let nextOpeningTag = openingTag;
+    if (urlAttrMatch) {
+        const currentUrl = urlAttrMatch[2] ?? urlAttrMatch[3] ?? '';
+        if (currentUrl === url)
+            return epicVideoBlock;
+        const quote = urlAttrMatch[1]?.startsWith("'") ? "'" : '"';
+        nextOpeningTag = openingTag.replace(urlAttrMatch[0], `url=${quote}${url}${quote}`);
+    }
+    else {
+        nextOpeningTag = openingTag.replace(/\/?>$/, (suffix) => {
+            return ` url="${url}"${suffix}`;
+        });
+    }
+    return epicVideoBlock.replace(openingTag, nextOpeningTag);
+}
+function upsertTitleEpicVideo({ content, url, }) {
+    const lineEnding = content.includes('\r\n') ? '\r\n' : '\n';
+    const lines = content.split(/\r?\n/);
+    const titleLineIndex = lines.findIndex((line) => /^\s{0,3}#\s+/.test(line));
+    if (titleLineIndex < 0) {
+        return {
+            status: 'error',
+            message: 'Missing top-level H1 title (`# ...`)',
+        };
+    }
+    let firstNonEmptyAfterTitle = titleLineIndex + 1;
+    while (firstNonEmptyAfterTitle < lines.length &&
+        lines[firstNonEmptyAfterTitle]?.trim() === '') {
+        firstNonEmptyAfterTitle++;
+    }
+    const lineAfterTitle = lines[firstNonEmptyAfterTitle]?.trimStart() ?? '';
+    if (lineAfterTitle.startsWith('<EpicVideo')) {
+        const blockStart = firstNonEmptyAfterTitle;
+        let blockEnd = -1;
+        for (let index = blockStart; index < lines.length; index++) {
+            const line = lines[index]?.trim() ?? '';
+            if (line.includes('/>') || line.includes('</EpicVideo>')) {
+                blockEnd = index;
+                break;
+            }
+        }
+        if (blockEnd < 0) {
+            return {
+                status: 'error',
+                message: 'Found a top EpicVideo block but could not find its closing tag',
+            };
+        }
+        const currentBlock = lines.slice(blockStart, blockEnd + 1).join(lineEnding);
+        const nextBlock = setEpicVideoUrl({ epicVideoBlock: currentBlock, url });
+        if (nextBlock === currentBlock) {
+            return {
+                status: 'success',
+                outcome: 'unchanged',
+                nextContent: content,
+            };
+        }
+        const nextLines = [
+            ...lines.slice(0, blockStart),
+            ...nextBlock.split(/\r?\n/),
+            ...lines.slice(blockEnd + 1),
+        ];
+        return {
+            status: 'success',
+            outcome: 'updated',
+            nextContent: nextLines.join(lineEnding),
+        };
+    }
+    const epicVideoLine = `<EpicVideo url="${url}" />`;
+    const nextLines = [
+        ...lines.slice(0, titleLineIndex + 1),
+        '',
+        epicVideoLine,
+        '',
+        ...lines.slice(firstNonEmptyAfterTitle),
+    ];
+    return {
+        status: 'success',
+        outcome: 'inserted',
+        nextContent: nextLines.join(lineEnding),
+    };
+}
+function formatNumberedList(items, { startAt = 1 } = {}) {
+    return items.map((item, index) => `${startAt + index}. ${item}`).join('\n');
+}
+function buildFileLessonSlotPlans(files) {
+    const plans = [];
+    const stepSlotByKey = new Map();
+    let nextLessonSlotIndex = 0;
+    for (const file of files) {
+        if ((file.kind === 'step-problem' || file.kind === 'step-solution') &&
+            typeof file.exerciseNumber === 'number' &&
+            typeof file.stepNumber === 'number') {
+            const key = `${file.exerciseNumber}:${file.stepNumber}`;
+            const existingSlot = stepSlotByKey.get(key);
+            if (typeof existingSlot === 'number') {
+                plans.push({ file, lessonSlotIndex: existingSlot });
+                continue;
+            }
+            const newSlot = nextLessonSlotIndex++;
+            stepSlotByKey.set(key, newSlot);
+            plans.push({ file, lessonSlotIndex: newSlot });
+            continue;
+        }
+        const slot = nextLessonSlotIndex++;
+        plans.push({ file, lessonSlotIndex: slot });
+    }
+    return { plans, requiredLessonSlots: nextLessonSlotIndex };
+}
+export async function setVideos(options = {}) {
+    const workshopRoot = path.resolve(options.workshopRoot ?? process.env.EPICSHOP_CONTEXT_CWD ?? process.cwd());
+    process.env.EPICSHOP_CONTEXT_CWD = workshopRoot;
+    const { silent = false, dryRun = false } = options;
+    const fail = (message, { warnings = [] } = {}) => {
+        if (!silent) {
+            console.log(chalk.bold.cyan('\n🛠️  Admin: Set videos\n'));
+            console.log(chalk.red(`❌ ${message}`));
+            if (warnings.length > 0) {
+                console.log();
+                for (const warning of warnings) {
+                    console.log(chalk.yellow(`⚠️ ${warning}`));
+                }
+            }
+            console.log();
+        }
+        return {
+            ...createFailureResult(message, { dryRun }),
+            warnings,
+        };
+    };
+    const packageJsonPath = path.join(workshopRoot, 'package.json');
+    let packageJson;
+    try {
+        const raw = await fs.readFile(packageJsonPath, 'utf8');
+        packageJson = JSON.parse(raw);
+    }
+    catch (error) {
+        return fail(`Failed to read/parse package.json: ${getErrorMessage(error)}`);
+    }
+    const product = packageJson && typeof packageJson === 'object'
+        ? packageJson.epicshop?.product
+        : null;
+    const productHost = product &&
+        typeof product === 'object' &&
+        typeof product.host === 'string'
+        ? product.host.trim()
+        : '';
+    const productSlug = product &&
+        typeof product === 'object' &&
+        typeof product.slug === 'string'
+        ? product.slug.trim()
+        : '';
+    if (!productHost) {
+        return fail('Missing `epicshop.product.host` in package.json (required for set-videos)');
+    }
+    if (/^https?:\/\//i.test(productHost) || productHost.includes('/')) {
+        return fail('`epicshop.product.host` should be a host only (for example: "www.epicweb.dev")');
+    }
+    if (!productSlug) {
+        return fail('Missing `epicshop.product.slug` in package.json (required for set-videos)');
+    }
+    const { files, errors, warnings } = await collectOrderedVideoFiles({
+        workshopRoot,
+    });
+    if (errors.length > 0) {
+        const message = `Cannot set videos because workshop structure is invalid:\n- ${errors.join('\n- ')}`;
+        return fail(message, {
+            warnings,
+        });
+    }
+    const normalizeLessonSlug = (value) => stripEpicAiSlugSuffix(value.trim());
+    const remoteResult = await fetchRemoteWorkshopLessons({
+        productHost,
+        workshopSlug: productSlug,
+        normalizeLessonSlug,
+        normalizeSectionSlug: normalizeLessonSlug,
+        requireNonEmptyLessonSlug: true,
+    });
+    if (remoteResult.status === 'error') {
+        return fail(remoteResult.message, {
+            warnings,
+        });
+    }
+    const remoteLessons = remoteResult.lessons;
+    if (remoteLessons.length === 0) {
+        return fail('Product API returned no lessons. Is the workshop published on the product site?', {
+            warnings,
+        });
+    }
+    const { plans: fileLessonSlotPlans, requiredLessonSlots } = buildFileLessonSlotPlans(files);
+    if (remoteLessons.length < requiredLessonSlots) {
+        const assignedPairs = fileLessonSlotPlans
+            .filter((plan) => plan.lessonSlotIndex < remoteLessons.length)
+            .map((plan) => {
+            const lesson = remoteLessons[plan.lessonSlotIndex];
+            if (!lesson)
+                return `${plan.file.relativePath} -> (no lesson)`;
+            const lessonUrl = formatProductLessonUrl({
+                productHost,
+                productSlug,
+                lessonSlug: lesson.slug,
+                sectionSlug: lesson.sectionSlug,
+            });
+            return `${plan.file.relativePath} -> ${lessonUrl}`;
+        });
+        const unassignedLocalFiles = fileLessonSlotPlans
+            .filter((plan) => plan.lessonSlotIndex >= remoteLessons.length)
+            .map((plan) => `${plan.file.relativePath} (lesson slot ${plan.lessonSlotIndex + 1})`);
+        const remoteLessonsInOrder = remoteLessons.map((lesson) => {
+            const lessonPath = lesson.sectionSlug
+                ? `${lesson.sectionSlug}/${lesson.slug}`
+                : lesson.slug;
+            const lessonUrl = formatProductLessonUrl({
+                productHost,
+                productSlug,
+                lessonSlug: lesson.slug,
+                sectionSlug: lesson.sectionSlug,
+            });
+            return `${lessonPath} -> ${lessonUrl}`;
+        });
+        const requiredLocalFilesInOrder = fileLessonSlotPlans.map((plan) => `${plan.file.relativePath} (lesson slot ${plan.lessonSlotIndex + 1})`);
+        return fail(`Not enough product lessons to map onto workshop files.\nExpected at least ${requiredLessonSlots} lessons, but received ${remoteLessons.length}.\nMissing ${requiredLessonSlots - remoteLessons.length} lesson(s).\nThis mapping uses one lesson slot for workshop intro/wrap-up, exercise intro/summary, and one shared lesson slot per exercise step (applied to both problem + solution files).\n\nAssigned file/video pairs (in order):\n${assignedPairs.length > 0 ? formatNumberedList(assignedPairs) : '(none)'}\n\nUnassigned local files (in order):\n${formatNumberedList(unassignedLocalFiles, {
+            startAt: assignedPairs.length + 1,
+        })}\n\nProduct lessons returned by API (in order):\n${formatNumberedList(remoteLessonsInOrder)}\n\nRequired local files (in order):\n${formatNumberedList(requiredLocalFilesInOrder)}\n\nHint: verify the product workshop has all expected lessons published and in the same order as the local exercise/step instruction files.`, {
+            warnings,
+        });
+    }
+    const plannedEdits = [];
+    const editErrors = [];
+    for (const plan of fileLessonSlotPlans) {
+        const lesson = remoteLessons[plan.lessonSlotIndex];
+        if (!lesson)
+            continue;
+        const targetUrl = formatProductLessonUrl({
+            productHost,
+            productSlug,
+            lessonSlug: lesson.slug,
+            sectionSlug: lesson.sectionSlug,
+        });
+        let currentContent = '';
+        try {
+            currentContent = await fs.readFile(plan.file.fullPath, 'utf8');
+        }
+        catch (error) {
+            editErrors.push(`Failed to read "${plan.file.relativePath}": ${getErrorMessage(error)}`);
+            continue;
+        }
+        const result = upsertTitleEpicVideo({
+            content: currentContent,
+            url: targetUrl,
+        });
+        if (result.status === 'error') {
+            editErrors.push(`${plan.file.relativePath}: ${result.message}`);
+            continue;
+        }
+        plannedEdits.push({
+            file: plan.file,
+            nextContent: result.nextContent,
+            outcome: result.outcome,
+        });
+    }
+    if (editErrors.length > 0) {
+        return fail(`Could not update videos for all files:\n- ${editErrors.join('\n- ')}`, {
+            warnings,
+        });
+    }
+    if (!dryRun) {
+        for (const edit of plannedEdits) {
+            if (edit.outcome === 'unchanged')
+                continue;
+            await fs.writeFile(edit.file.fullPath, edit.nextContent);
+        }
+    }
+    const inserted = plannedEdits.filter((edit) => edit.outcome === 'inserted').length;
+    const updated = plannedEdits.filter((edit) => edit.outcome === 'updated').length;
+    const unchanged = plannedEdits.filter((edit) => edit.outcome === 'unchanged').length;
+    if (remoteLessons.length > requiredLessonSlots) {
+        const extras = remoteLessons.slice(requiredLessonSlots).map((lesson) => formatProductLessonUrl({
+            productHost,
+            productSlug,
+            lessonSlug: lesson.slug,
+            sectionSlug: lesson.sectionSlug,
+        }));
+        warnings.push(`Product has ${extras.length} extra lesson(s) beyond mapped lesson slots:\n- ${extras.join('\n- ')}`);
+    }
+    if (!silent) {
+        console.log(chalk.bold.cyan('\n🛠️  Admin: Set videos\n'));
+        console.log(chalk.green(`✅ ${dryRun ? 'Planned' : 'Updated'} EpicVideo mappings (inserted: ${inserted}, updated: ${updated}, unchanged: ${unchanged})`));
+        if (dryRun) {
+            console.log(chalk.yellow('🧪 Dry run enabled: no files were modified.'));
+        }
+        if (warnings.length > 0) {
+            console.log();
+            for (const warning of warnings) {
+                console.log(chalk.yellow(`⚠️ ${warning}`));
+            }
+        }
+        console.log();
+    }
+    return {
+        success: true,
+        message: dryRun
+            ? 'Set videos dry run completed successfully'
+            : 'Set videos completed successfully',
+        inserted,
+        updated,
+        unchanged,
+        warnings,
+        dryRun,
+    };
+}

package/dist/commands/admin/workshop-content-utils.d.ts

@@ -0,0 +1,33 @@
+import { type Dirent } from 'node:fs';
+export type RemoteLesson = {
+    slug: string;
+    sectionSlug: string | null;
+};
+type NormalizeSlug = (value: string) => string;
+export declare function stripEpicAiSlugSuffix(value: string): string;
+export declare function formatProductLessonUrl({ productHost, productSlug, lessonSlug, sectionSlug, }: {
+    productHost: string;
+    productSlug: string;
+    lessonSlug: string;
+    sectionSlug: string | null;
+}): string;
+export declare function isDirectory(targetPath: string): Promise<boolean>;
+export declare function resolveMdxFile(dir: string, baseName: 'README' | 'FINISHED'): Promise<string | null>;
+export declare function collectStepDirectories(entries: Array<Dirent>, exerciseRoot: string): Map<number, {
+    problems: Array<string>;
+    solutions: Array<string>;
+}>;
+export declare function fetchRemoteWorkshopLessons({ productHost, workshopSlug, normalizeLessonSlug, normalizeSectionSlug, requireNonEmptyLessonSlug, }: {
+    productHost: string;
+    workshopSlug: string;
+    normalizeLessonSlug?: NormalizeSlug;
+    normalizeSectionSlug?: NormalizeSlug;
+    requireNonEmptyLessonSlug?: boolean;
+}): Promise<{
+    status: 'success';
+    lessons: Array<RemoteLesson>;
+} | {
+    status: 'error';
+    message: string;
+}>;
+export {};

package/dist/commands/admin/workshop-content-utils.js

@@ -0,0 +1,168 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getAuthInfo } from '@epic-web/workshop-utils/db.server';
+import { getErrorMessage } from '@epic-web/workshop-utils/utils';
+import { pathExists } from "../../utils/filesystem.js";
+export function stripEpicAiSlugSuffix(value) {
+    // EpicAI embeds sometimes include a `~...` suffix in the slug segment.
+    return value.replace(/~[^ ]*$/, '');
+}
+export function formatProductLessonUrl({ productHost, productSlug, lessonSlug, sectionSlug, }) {
+    // The product site will typically redirect to a section-specific path when needed.
+    return sectionSlug
+        ? `https://${productHost}/workshops/${productSlug}/${sectionSlug}/${lessonSlug}`
+        : `https://${productHost}/workshops/${productSlug}/${lessonSlug}`;
+}
+export async function isDirectory(targetPath) {
+    try {
+        return (await fs.stat(targetPath)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveMdxFile(dir, baseName) {
+    const mdx = path.join(dir, `${baseName}.mdx`);
+    if (await pathExists(mdx))
+        return mdx;
+    return null;
+}
+export function collectStepDirectories(entries, exerciseRoot) {
+    const stepDirRegex = /^(?<stepNumber>\d+)\.(?<type>problem|solution)(\..*)?$/;
+    const stepsByNumber = new Map();
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const match = stepDirRegex.exec(entry.name);
+        if (!match?.groups)
+            continue;
+        const stepNumber = Number(match.groups.stepNumber);
+        const type = match.groups.type;
+        if (!Number.isFinite(stepNumber) || stepNumber <= 0)
+            continue;
+        const current = stepsByNumber.get(stepNumber) ?? {
+            problems: [],
+            solutions: [],
+        };
+        const fullStepDir = path.join(exerciseRoot, entry.name);
+        if (type === 'problem')
+            current.problems.push(fullStepDir);
+        if (type === 'solution')
+            current.solutions.push(fullStepDir);
+        stepsByNumber.set(stepNumber, current);
+    }
+    return stepsByNumber;
+}
+export async function fetchRemoteWorkshopLessons({ productHost, workshopSlug, normalizeLessonSlug, normalizeSectionSlug, requireNonEmptyLessonSlug = false, }) {
+    const url = `https://${productHost}/api/workshops/${encodeURIComponent(workshopSlug)}`;
+    const fetchOnce = async (accessToken) => {
+        const timeout = AbortSignal.timeout(15_000);
+        const headers = {};
+        if (accessToken)
+            headers.authorization = `Bearer ${accessToken}`;
+        return fetch(url, { headers, signal: timeout });
+    };
+    let response = null;
+    try {
+        response = await fetchOnce();
+    }
+    catch (error) {
+        return {
+            status: 'error',
+            message: `Failed to fetch product workshop data: ${getErrorMessage(error)}`,
+        };
+    }
+    if (response.status === 401 || response.status === 403) {
+        const authInfo = await getAuthInfo({ productHost }).catch(() => null);
+        const accessToken = authInfo?.tokenSet?.access_token;
+        if (accessToken) {
+            try {
+                response = await fetchOnce(accessToken);
+            }
+            catch (error) {
+                return {
+                    status: 'error',
+                    message: `Failed to fetch product workshop data (after auth): ${getErrorMessage(error)}`,
+                };
+            }
+        }
+    }
+    if (!response.ok) {
+        const body = await response.text().catch(() => '');
+        const hint = response.status === 401 || response.status === 403
+            ? ` (try: npx epicshop auth login ${productHost.replace(/^www\./, '')})`
+            : response.status === 404
+                ? ` (check epicshop.product.host + epicshop.product.slug)`
+                : '';
+        return {
+            status: 'error',
+            message: `Product API request failed: ${response.status} ${response.statusText}${hint}${body ? `\n${body}` : ''}`,
+        };
+    }
+    let data;
+    try {
+        data = await response.json();
+    }
+    catch (error) {
+        return {
+            status: 'error',
+            message: `Product API response was not valid JSON: ${getErrorMessage(error)}`,
+        };
+    }
+    const resources = data && typeof data === 'object' && 'resources' in data
+        ? data.resources
+        : null;
+    if (!Array.isArray(resources)) {
+        return {
+            status: 'error',
+            message: `Product API response did not include an array "resources" field`,
+        };
+    }
+    const applyNormalizer = (value, normalizer) => {
+        return normalizer ? normalizer(value) : value;
+    };
+    const lessons = [];
+    for (const resource of resources) {
+        if (!resource || typeof resource !== 'object')
+            continue;
+        const item = resource;
+        if (item._type === 'lesson') {
+            const slug = item.slug;
+            if (typeof slug === 'string') {
+                const normalizedSlug = applyNormalizer(slug, normalizeLessonSlug);
+                if (requireNonEmptyLessonSlug && normalizedSlug.trim().length === 0) {
+                    continue;
+                }
+                lessons.push({ slug: normalizedSlug, sectionSlug: null });
+            }
+            continue;
+        }
+        if (item._type === 'section') {
+            let sectionSlug = null;
+            if (typeof item.slug === 'string') {
+                const normalizedSectionSlug = applyNormalizer(item.slug, normalizeSectionSlug);
+                const trimmedSectionSlug = normalizedSectionSlug.trim();
+                if (trimmedSectionSlug.length > 0) {
+                    sectionSlug = trimmedSectionSlug;
+                }
+            }
+            const sectionLessons = item.lessons;
+            if (!Array.isArray(sectionLessons))
+                continue;
+            for (const lesson of sectionLessons) {
+                if (!lesson || typeof lesson !== 'object')
+                    continue;
+                const lessonItem = lesson;
+                const slug = lessonItem.slug;
+                if (typeof slug === 'string') {
+                    const normalizedSlug = applyNormalizer(slug, normalizeLessonSlug);
+                    if (requireNonEmptyLessonSlug && normalizedSlug.trim().length === 0) {
+                        continue;
+                    }
+                    lessons.push({ slug: normalizedSlug, sectionSlug });
+                }
+            }
+        }
+    }
+    return { status: 'success', lessons };
+}

package/dist/commands/admin.d.ts

@@ -1 +1,2 @@
 export { launchReadiness, type LaunchReadinessOptions, type LaunchReadinessResult, } from "./admin/launch-readiness.js";
+export { setVideos, type SetVideosOptions, type SetVideosResult, } from "./admin/set-videos.js";

package/dist/commands/admin.js

@@ -1 +1,2 @@
 export { launchReadiness, } from "./admin/launch-readiness.js";
+export { setVideos, } from "./admin/set-videos.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "epicshop",
-  "version": "6.84.7",
+  "version": "6.85.0",
   "publishConfig": {
     "access": "public"
   },
@@ -105,7 +105,7 @@
     "build:watch": "nx watch --projects=epicshop -- nx run \\$NX_PROJECT_NAME:build"
   },
   "dependencies": {
-    "@epic-web/workshop-utils": "6.84.7",
+    "@epic-web/workshop-utils": "6.85.0",
     "@inquirer/prompts": "^8.2.0",
     "@sentry/node": "^10.38.0",
     "chalk": "^5.6.2",