epicshop 6.75.1 → 6.76.0

package/dist/cli.js

@@ -280,11 +280,15 @@ const cli = yargs(args)
         .positional('subcommand', {
         describe: 'Config subcommand (reset)',
         type: 'string',
-        choices: ['reset'],
+        choices: ['reset', 'editor'],
     })
         .option('repos-dir', {
         type: 'string',
         description: 'Set the default directory for workshop repos',
+    })
+        .option('editor', {
+        type: 'string',
+        description: 'Set the preferred editor command',
     })
         .option('silent', {
         alias: 's',
@@ -294,12 +298,19 @@ const cli = yargs(args)
     })
         .example('$0 config', 'View current configuration')
         .example('$0 config reset', 'Delete config file and reset to defaults')
-        .example('$0 config --repos-dir ~/epicweb', 'Set the repos directory');
+        .example('$0 config --repos-dir ~/epicweb', 'Set the repos directory')
+        .example('$0 config editor', 'Choose a preferred editor')
+        .example('$0 config --editor code', 'Set preferred editor to VS Code');
 }, async (argv) => {
     const { config } = await import("./commands/workshops.js");
     const result = await config({
-        subcommand: argv.subcommand === 'reset' ? 'reset' : undefined,
+        subcommand: argv.subcommand === 'reset'
+            ? 'reset'
+            : argv.subcommand === 'editor'
+                ? 'editor'
+                : undefined,
         reposDir: argv.reposDir,
+        preferredEditor: argv.editor,
         silent: argv.silent,
     });
     if (!result.success) {

package/dist/commands/cleanup.js

@@ -6,6 +6,7 @@ import path from 'node:path';
 import { resolveCacheDir, resolveFallbackPath, resolvePrimaryDir, resolvePrimaryPath, } from '@epic-web/workshop-utils/data-storage.server';
 import { deleteWorkshop, getReposDirectory, getUnpushedChanges, } from '@epic-web/workshop-utils/workshops.server';
 import chalk from 'chalk';
+import ora from 'ora';
 import { assertCanPrompt } from "../utils/cli-runtime.js";
 const CLEANUP_TARGETS = [
     {
@@ -63,6 +64,19 @@ function resolveWorkshopCleanupTargets(targets) {
     const allowed = new Set(WORKSHOP_CLEANUP_TARGETS.map((target) => target.value));
     return Array.from(new Set(targets.filter((target) => allowed.has(target))));
 }
+function startSpinner(text, silent) {
+    if (silent)
+        return null;
+    return ora(text).start();
+}
+function updateSpinner(spinner, text) {
+    if (spinner)
+        spinner.text = text;
+}
+function stopSpinner(spinner) {
+    if (spinner?.isSpinning)
+        spinner.stop();
+}
 async function resolveCleanupPaths(paths = {}) {
     const reposDir = paths.reposDir ?? (await getReposDirectory());
     const cacheDir = paths.cacheDir ?? resolveCacheDir();
@@ -403,9 +417,11 @@ async function getDataCleanupSizeSummary(dataPaths) {
     }
     return { preferencesBytes, authBytes };
 }
-async function getWorkshopSummaries({ workshops, cacheDir, }) {
+async function getWorkshopSummaries({ workshops, cacheDir, onProgress, }) {
     const summaries = [];
-    for (const workshop of workshops) {
+    const total = workshops.length;
+    for (const [index, workshop] of workshops.entries()) {
+        onProgress?.({ current: index + 1, total, workshop });
         const id = getWorkshopInstanceId(workshop.path);
         const sizeBytes = await getPathSize(workshop.path);
         const cacheBytes = await getPathSize(path.join(cacheDir, id));
@@ -520,17 +536,47 @@ export async function cleanup({ silent = false, force = false, targets, workshop
                 selectedTargets.push('workshops');
             }
         }
-        const { reposDir, cacheDir, legacyCacheDir, dataPaths, offlineVideosDir } = await resolveCleanupPaths(paths);
-        const allWorkshops = await listWorkshopsInDirectory(reposDir);
-        const workshopSummaries = await getWorkshopSummaries({
-            workshops: allWorkshops,
-            cacheDir,
-        });
-        const workshopBytes = workshopSummaries.reduce((total, workshop) => total + workshop.sizeBytes, 0);
-        const legacyCacheBytes = await getPathSize(legacyCacheDir);
-        const cacheBytes = (await getPathSize(cacheDir)) + legacyCacheBytes;
-        const offlineVideosBytes = await getPathSize(offlineVideosDir);
-        const { preferencesBytes, authBytes } = await getDataCleanupSizeSummary(dataPaths);
+        const analysisSpinner = startSpinner('Scanning local epicshop data...', silent);
+        let reposDir = '';
+        let cacheDir = '';
+        let legacyCacheDir = '';
+        let dataPaths = [];
+        let offlineVideosDir = '';
+        let workshopSummaries = [];
+        let workshopBytes = 0;
+        let legacyCacheBytes = 0;
+        let cacheBytes = 0;
+        let offlineVideosBytes = 0;
+        let preferencesBytes = 0;
+        let authBytes = 0;
+        try {
+            updateSpinner(analysisSpinner, 'Resolving cleanup locations...');
+            ({ reposDir, cacheDir, legacyCacheDir, dataPaths, offlineVideosDir } =
+                await resolveCleanupPaths(paths));
+            updateSpinner(analysisSpinner, 'Finding installed workshops...');
+            const allWorkshops = await listWorkshopsInDirectory(reposDir);
+            updateSpinner(analysisSpinner, 'Calculating workshop sizes...');
+            workshopSummaries = await getWorkshopSummaries({
+                workshops: allWorkshops,
+                cacheDir,
+                onProgress: (progress) => {
+                    updateSpinner(analysisSpinner, `Calculating workshop sizes (${progress.current}/${progress.total}): ${progress.workshop.repoName}`);
+                },
+            });
+            workshopBytes = workshopSummaries.reduce((total, workshop) => total + workshop.sizeBytes, 0);
+            updateSpinner(analysisSpinner, 'Calculating cache sizes...');
+            legacyCacheBytes = await getPathSize(legacyCacheDir);
+            const cacheDirBytes = await getPathSize(cacheDir);
+            cacheBytes = cacheDirBytes + legacyCacheBytes;
+            updateSpinner(analysisSpinner, 'Calculating offline video sizes...');
+            offlineVideosBytes = await getPathSize(offlineVideosDir);
+            updateSpinner(analysisSpinner, 'Scanning preferences and auth data...');
+            ({ preferencesBytes, authBytes } =
+                await getDataCleanupSizeSummary(dataPaths));
+        }
+        finally {
+            stopSpinner(analysisSpinner);
+        }
         const cleanupChoices = CLEANUP_TARGETS.map((target) => {
             const sizeByTarget = {
                 workshops: workshopBytes,
@@ -580,8 +626,17 @@ export async function cleanup({ silent = false, force = false, targets, workshop
                 const selectedWorkshopIds = new Set(selectedWorkshops.map((workshop) => workshop.id));
                 const workshopFileBytes = selectedWorkshops.reduce((total, workshop) => total + workshop.sizeBytes, 0);
                 const workshopCacheBytes = selectedWorkshops.reduce((total, workshop) => total + workshop.cacheBytes, 0);
-                const offlineVideoIndex = await readOfflineVideoIndex(offlineVideosDir);
-                const workshopOfflineBytes = await estimateOfflineVideoBytesForWorkshops(offlineVideosDir, offlineVideoIndex, selectedWorkshopIds);
+                const selectionSpinner = startSpinner('Calculating workshop cleanup sizes...', silent);
+                let workshopOfflineBytes = 0;
+                try {
+                    updateSpinner(selectionSpinner, 'Loading offline video index...');
+                    const offlineVideoIndex = await readOfflineVideoIndex(offlineVideosDir);
+                    updateSpinner(selectionSpinner, 'Calculating workshop offline video sizes...');
+                    workshopOfflineBytes = await estimateOfflineVideoBytesForWorkshops(offlineVideosDir, offlineVideoIndex, selectedWorkshopIds);
+                }
+                finally {
+                    stopSpinner(selectionSpinner);
+                }
                 const workshopChoices = WORKSHOP_CLEANUP_TARGETS.map((target) => {
                     const sizeByTarget = {
                         files: workshopFileBytes,
@@ -618,14 +673,21 @@ export async function cleanup({ silent = false, force = false, targets, workshop
                 console.log(chalk.gray(message));
             return { success: true, message, selectedTargets };
         }
-        const unpushedSummaries = !silent &&
+        let unpushedSummaries = [];
+        if (!silent &&
             selectedWorkshopTargets.includes('files') &&
-            selectedWorkshops.length > 0
-            ? await Promise.all(selectedWorkshops.map(async (workshop) => ({
-                workshop,
-                unpushedChanges: await getUnpushedChanges(workshop.path),
-            })))
-            : [];
+            selectedWorkshops.length > 0) {
+            const unpushedSpinner = startSpinner('Checking for unpushed workshop changes...', silent);
+            try {
+                unpushedSummaries = await Promise.all(selectedWorkshops.map(async (workshop) => ({
+                    workshop,
+                    unpushedChanges: await getUnpushedChanges(workshop.path),
+                })));
+            }
+            finally {
+                stopSpinner(unpushedSpinner);
+            }
+        }
         if (!silent) {
             console.log(chalk.yellow('This will clean up the following:'));
             if (selectedWorkshopTargets.includes('files')) {

package/dist/commands/workshops.d.ts

@@ -28,8 +28,9 @@ export type StartOptions = {
 };
 export type ConfigOptions = {
     reposDir?: string;
+    preferredEditor?: string;
     silent?: boolean;
-    subcommand?: 'reset' | 'delete';
+    subcommand?: 'reset' | 'delete' | 'editor';
 };
 /**
  * Add a workshop by cloning from epicweb-dev GitHub org and running setup

package/dist/commands/workshops.js

@@ -78,6 +78,7 @@ const GitHubRepoSchema = z.object({
     stargazers_count: z.number(),
     topics: z.array(z.string()).default([]),
     archived: z.boolean(),
+    default_branch: z.string().optional(),
 });
 const GitHubSearchResponseSchema = z.object({
     total_count: z.number(),
@@ -99,6 +100,20 @@ function resolvePathWithTilde(inputPath) {
     }
     return trimmed;
 }
+function formatEditorChoiceName(editor) {
+    return editor.label === editor.command
+        ? editor.label
+        : `${editor.label} (${editor.command})`;
+}
+async function getInstalledEditorChoices() {
+    const { getAvailableEditors } = await import('@epic-web/workshop-utils/launch-editor.server');
+    const editors = getAvailableEditors();
+    return editors.map((editor) => ({
+        name: formatEditorChoiceName(editor),
+        value: editor.command,
+        description: editor.label === editor.command ? undefined : editor.command,
+    }));
+}
 function parseRepoSpecifier(value) {
     const trimmed = value.trim();
     const hashIndex = trimmed.indexOf('#');
@@ -113,8 +128,11 @@ function parseRepoSpecifier(value) {
     return { repoName, repoRef };
 }
 function getGitHubHeaders() {
+    return getGitHubHeadersWithAccept('application/vnd.github.v3+json');
+}
+function getGitHubHeadersWithAccept(accept) {
     const headers = {
-        Accept: 'application/vnd.github.v3+json',
+        Accept: accept,
         'User-Agent': 'epicshop-cli',
     };
     if (GITHUB_TOKEN) {
@@ -122,6 +140,47 @@ function getGitHubHeaders() {
     }
     return headers;
 }
+const DEFAULT_BRANCHES = ['main', 'master'];
+function buildRawPackageJsonUrls(repoName, defaultBranch) {
+    const branches = [defaultBranch, ...DEFAULT_BRANCHES].filter((branch) => Boolean(branch));
+    const uniqueBranches = Array.from(new Set(branches));
+    return uniqueBranches.map((branch) => `https://raw.githubusercontent.com/${GITHUB_ORG}/${repoName}/${branch}/package.json`);
+}
+async function parsePackageJsonResponse(response) {
+    try {
+        const parsed = PackageJsonSchema.safeParse(await response.json());
+        return parsed.success ? parsed.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function fetchPackageJsonFromUrl(url, headers) {
+    try {
+        const response = await fetch(url, { headers });
+        if (!response.ok)
+            return null;
+        return await parsePackageJsonResponse(response);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeProductHost(host) {
+    if (!host)
+        return undefined;
+    const normalized = host
+        .replace(/^https?:\/\//, '')
+        .replace(/\/$/, '')
+        .toLowerCase();
+    if (normalized === 'epicweb.dev')
+        return 'www.epicweb.dev';
+    if (normalized === 'epicreact.dev')
+        return 'www.epicreact.dev';
+    if (normalized === 'epicai.pro')
+        return 'www.epicai.pro';
+    return normalized;
+}
 /**
  * Fetch available workshops from GitHub (epicweb-dev org with 'workshop' topic)
  */
@@ -175,31 +234,30 @@ async function fetchAvailableWorkshops() {
 /**
  * Fetch a workshop's package.json from GitHub raw content
  */
-async function fetchWorkshopPackageJson(repoName) {
+async function fetchWorkshopPackageJson(repo) {
     return cachified({
-        key: `github-package-json:${repoName}`,
+        key: `github-package-json:${repo.name}`,
         cache: githubCache,
         ttl: 1000 * 60 * 60 * 6, // 6 hours
         swr: 1000 * 60 * 60 * 24 * 30, // 30 days stale-while-revalidate
         checkValue: PackageJsonSchema.nullable(),
-        async getFreshValue() {
-            const url = `https://raw.githubusercontent.com/${GITHUB_ORG}/${repoName}/main/package.json`;
-            const response = await fetch(url, {
-                headers: {
-                    'User-Agent': 'epicshop-cli',
-                    ...(GITHUB_TOKEN ? { Authorization: `Bearer ${GITHUB_TOKEN}` } : {}),
-                },
-            });
-            if (!response.ok) {
-                return null;
-            }
-            try {
-                const parsed = PackageJsonSchema.safeParse(await response.json());
-                return parsed.success ? parsed.data : null;
+        async getFreshValue(context) {
+            const rawHeaders = getGitHubHeadersWithAccept('application/vnd.github.raw');
+            const rawUrls = buildRawPackageJsonUrls(repo.name, repo.default_branch);
+            for (const url of rawUrls) {
+                const packageJson = await fetchPackageJsonFromUrl(url, rawHeaders);
+                if (packageJson) {
+                    return packageJson;
+                }
             }
-            catch {
-                return null;
+            const apiUrl = `https://api.github.com/repos/${GITHUB_ORG}/${repo.name}/contents/package.json`;
+            const apiPackageJson = await fetchPackageJsonFromUrl(apiUrl, getGitHubHeadersWithAccept('application/vnd.github.raw'));
+            if (apiPackageJson) {
+                return apiPackageJson;
             }
+            context.metadata.ttl = 1000 * 60;
+            context.metadata.swr = 0;
+            return null;
         },
     });
 }
@@ -207,13 +265,17 @@ async function fetchWorkshopPackageJson(repoName) {
  * Enrich workshops with metadata from their package.json files
  */
 async function enrichWorkshopsWithMetadata(workshops) {
-    const packageJsons = await Promise.all(workshops.map((w) => fetchWorkshopPackageJson(w.name)));
+    const packageJsons = await Promise.all(workshops.map((w) => fetchWorkshopPackageJson({
+        name: w.name,
+        default_branch: w.default_branch,
+    })));
     return workshops.map((workshop, index) => {
         const packageJson = packageJsons[index];
         const config = packageJson ? parseEpicshopConfig(packageJson) : null;
+        const productHost = normalizeProductHost(config?.product?.host);
         return {
             ...workshop,
-            productHost: config?.product?.host,
+            productHost,
             productSlug: config?.product?.slug,
             productDisplayName: config?.product?.displayName,
             instructorName: config?.instructor?.name,
@@ -251,11 +313,14 @@ async function checkWorkshopDownloadStatus(workshops) {
 /**
  * Check access for workshops in parallel
  */
-async function checkWorkshopAccess(workshops) {
+async function checkWorkshopAccess(workshops, authStatusMap) {
     const accessResults = await Promise.all(workshops.map(async (workshop) => {
         if (!workshop.productHost || !workshop.productSlug) {
             return undefined;
         }
+        if (authStatusMap?.get(workshop.productHost) === false) {
+            return undefined;
+        }
         return userHasAccessToWorkshop({
             productHost: workshop.productHost,
             workshopSlug: workshop.productSlug,
@@ -266,6 +331,57 @@ async function checkWorkshopAccess(workshops) {
         hasAccess: accessResults[index],
     }));
 }
+async function resolvePreferredEditor({ silent, }) {
+    const { getPreferredEditor, setPreferredEditor } = await import('@epic-web/workshop-utils/workshops.server');
+    const { getDefaultEditorCommand, formatEditorLabel } = await import('@epic-web/workshop-utils/launch-editor.server');
+    const preferredEditor = await getPreferredEditor();
+    if (preferredEditor)
+        return preferredEditor;
+    const defaultEditor = getDefaultEditorCommand();
+    if (silent)
+        return defaultEditor;
+    assertCanPrompt({
+        reason: 'choose a preferred editor',
+        hints: ['Set it later with: npx epicshop config editor'],
+    });
+    const { select, confirm } = await import('@inquirer/prompts');
+    const availableEditors = await getInstalledEditorChoices();
+    if (defaultEditor) {
+        const defaultLabel = formatEditorLabel(defaultEditor);
+        if (availableEditors.length === 0) {
+            const useDefault = await confirm({
+                message: `Use ${defaultLabel} to open workshops?`,
+                default: true,
+            });
+            if (useDefault) {
+                await setPreferredEditor(defaultEditor);
+                return defaultEditor;
+            }
+            return null;
+        }
+        const decision = await select({
+            message: `Open workshops with ${defaultLabel}?`,
+            choices: [
+                { name: `Use ${defaultLabel}`, value: 'use' },
+                { name: 'Choose a different editor', value: 'choose' },
+            ],
+        });
+        if (decision === 'use') {
+            await setPreferredEditor(defaultEditor);
+            return defaultEditor;
+        }
+    }
+    if (availableEditors.length === 0) {
+        console.log(chalk.yellow('⚠️  No supported editors detected. Set EPICSHOP_EDITOR or install a supported editor.'));
+        return defaultEditor;
+    }
+    const selectedEditor = await select({
+        message: 'Select your preferred editor:',
+        choices: availableEditors,
+    });
+    await setPreferredEditor(selectedEditor);
+    return selectedEditor;
+}
 /**
  * Helper function to add a single workshop by repo name
  * This handles the actual cloning and setup logic
@@ -497,7 +613,7 @@ export async function add(options) {
                     console.log();
                 }
                 spinner.start('Checking access...');
-                enrichedWorkshops = await checkWorkshopAccess(enrichedWorkshops);
+                enrichedWorkshops = await checkWorkshopAccess(enrichedWorkshops, authStatusMap);
                 enrichedWorkshops.sort((a, b) => {
                     const aHasAccess = a.hasAccess === true;
                     const aIsDownloaded = a.isDownloaded === true;
@@ -1294,6 +1410,10 @@ export async function openWorkshop(options = {}) {
                 console.log(chalk.red(`❌ ${message}`));
             return { success: false, message };
         }
+        const preferredEditor = await resolvePreferredEditor({ silent });
+        if (preferredEditor) {
+            process.env.EPICSHOP_EDITOR = preferredEditor;
+        }
         if (!silent) {
             console.log(chalk.cyan(`📂 Opening ${chalk.bold(workshopToOpen.title)} in your editor...`));
             console.log(chalk.gray(`   Path: ${workshopToOpen.path}\n`));
@@ -1329,7 +1449,7 @@ export async function openWorkshop(options = {}) {
 export async function config(options = {}) {
     const { silent = false } = options;
     try {
-        const { getReposDirectory, setReposDirectory, isReposDirectoryConfigured, loadConfig, saveConfig, getDefaultReposDir, deleteConfig, } = await import('@epic-web/workshop-utils/workshops.server');
+        const { getReposDirectory, setReposDirectory, isReposDirectoryConfigured, loadConfig, saveConfig, getDefaultReposDir, getPreferredEditor, setPreferredEditor, clearPreferredEditor, deleteConfig, } = await import('@epic-web/workshop-utils/workshops.server');
         // Handle reset subcommand
         if (options.subcommand === 'reset' || options.subcommand === 'delete') {
             if (silent) {
@@ -1369,6 +1489,13 @@ export async function config(options = {}) {
             if (!silent)
                 console.log(chalk.green(`✅ ${message}`));
         }
+        if (options.preferredEditor) {
+            await setPreferredEditor(options.preferredEditor);
+            const message = `Preferred editor set to: ${options.preferredEditor}`;
+            messages.push(message);
+            if (!silent)
+                console.log(chalk.green(`✅ ${message}`));
+        }
         // If either option was set, return now
         if (messages.length > 0) {
             return { success: true, message: messages.join('; ') };
@@ -1376,20 +1503,36 @@ export async function config(options = {}) {
         if (silent) {
             // In silent mode, just return current config
             const reposDir = await getReposDirectory();
-            return { success: true, message: `Repos directory: ${reposDir}` };
+            const preferredEditor = await getPreferredEditor();
+            const editorMessage = preferredEditor
+                ? `Preferred editor: ${preferredEditor}`
+                : 'Preferred editor: not set';
+            return {
+                success: true,
+                message: `Repos directory: ${reposDir}; ${editorMessage}`,
+            };
         }
         // Interactive config selection
         assertCanPrompt({
             reason: 'select a configuration option',
             hints: [
                 'Set repos dir directly: npx epicshop config --repos-dir <path>',
+                'Set preferred editor: npx epicshop config --editor <command>',
                 'Delete config non-interactively: npx epicshop config reset --silent',
             ],
         });
-        const { search, confirm } = await import('@inquirer/prompts');
+        const { search, confirm, select } = await import('@inquirer/prompts');
+        const { formatEditorLabel } = await import('@epic-web/workshop-utils/launch-editor.server');
         const reposDir = await getReposDirectory();
         const isConfigured = await isReposDirectoryConfigured();
         const defaultDir = getDefaultReposDir();
+        const preferredEditor = await getPreferredEditor();
+        const preferredEditorDescription = preferredEditor
+            ? formatEditorChoiceName({
+                label: formatEditorLabel(preferredEditor),
+                command: preferredEditor,
+            })
+            : 'Not set';
         // Build config options
         const configOptions = [
             {
@@ -1397,13 +1540,92 @@ export async function config(options = {}) {
                 value: 'repos-dir',
                 description: isConfigured ? reposDir : `${reposDir} (default)`,
             },
+            {
+                name: 'Preferred editor',
+                value: 'preferred-editor',
+                description: preferredEditorDescription,
+            },
             {
                 name: `Reset config file`,
                 value: 'reset',
                 description: 'Delete config file and reset all settings to defaults',
             },
         ];
+        const handlePreferredEditorConfig = async () => {
+            console.log();
+            console.log(chalk.bold('  Current value:'));
+            if (preferredEditor) {
+                console.log(chalk.white(`  ${preferredEditorDescription}`));
+            }
+            else {
+                console.log(chalk.gray('  Not set'));
+            }
+            console.log();
+            const actionChoices = [
+                {
+                    name: 'Edit',
+                    value: 'edit',
+                    description: 'Choose a preferred editor',
+                },
+                ...(preferredEditor
+                    ? [
+                        {
+                            name: 'Remove',
+                            value: 'remove',
+                            description: 'Clear the preferred editor',
+                        },
+                    ]
+                    : []),
+                {
+                    name: 'Cancel',
+                    value: 'cancel',
+                    description: 'Go back without changes',
+                },
+            ];
+            const action = await search({
+                message: 'What would you like to do?',
+                source: async (input) => {
+                    if (!input)
+                        return actionChoices;
+                    return matchSorter(actionChoices, input, {
+                        keys: ['name', 'value', 'description'],
+                    });
+                },
+            });
+            if (action === 'edit') {
+                const editorChoices = await getInstalledEditorChoices();
+                if (editorChoices.length === 0) {
+                    console.log(chalk.yellow('⚠️  No supported editors detected. Set EPICSHOP_EDITOR or install a supported editor.'));
+                    return {
+                        success: true,
+                        message: 'No supported editors detected',
+                    };
+                }
+                const selectedEditor = await select({
+                    message: 'Select your preferred editor:',
+                    choices: editorChoices,
+                });
+                await setPreferredEditor(selectedEditor);
+                console.log();
+                console.log(chalk.green(`✅ Preferred editor set to: ${chalk.bold(selectedEditor)}`));
+                return {
+                    success: true,
+                    message: `Preferred editor set to: ${selectedEditor}`,
+                };
+            }
+            if (action === 'remove') {
+                await clearPreferredEditor();
+                console.log();
+                console.log(chalk.green('✅ Preferred editor cleared.'));
+                return { success: true, message: 'Preferred editor cleared' };
+            }
+            console.log(chalk.gray('\nNo changes made.'));
+            return { success: true, message: 'Cancelled' };
+        };
         console.log(chalk.bold.cyan('\n⚙️  Workshop Configuration\n'));
+        if (options.subcommand === 'editor') {
+            return await handlePreferredEditorConfig();
+        }
         const selectedConfig = await search({
             message: 'Select a setting to configure:',
             source: async (input) => {
@@ -1433,6 +1655,9 @@ export async function config(options = {}) {
                 return { success: true, message: 'Cancelled' };
             }
         }
+        if (selectedConfig === 'preferred-editor') {
+            return await handlePreferredEditorConfig();
+        }
         if (selectedConfig === 'repos-dir') {
             // Show current value and actions
             console.log();
@@ -1842,7 +2067,7 @@ async function promptAndSetupAccessibleWorkshops() {
         else {
             spinner.start('Checking access...');
         }
-        enrichedWorkshops = await checkWorkshopAccess(enrichedWorkshops);
+        enrichedWorkshops = await checkWorkshopAccess(enrichedWorkshops, authStatusMap);
         spinner.succeed(`Found ${enrichedWorkshops.length} available workshops`);
     }
     catch (error) {
@@ -1851,21 +2076,33 @@ async function promptAndSetupAccessibleWorkshops() {
         console.log(chalk.yellow(`⚠️  Could not load workshops right now. Skipping this step.\n`));
         return;
     }
-    const candidates = enrichedWorkshops.filter((w) => w.name !== TUTORIAL_REPO && w.hasAccess === true && !w.isDownloaded);
-    if (candidates.length === 0) {
+    const availableWorkshops = enrichedWorkshops.filter((w) => w.name !== TUTORIAL_REPO && !w.isDownloaded);
+    const accessibleWorkshops = availableWorkshops.filter((w) => w.hasAccess === true);
+    const selectableWorkshops = accessibleWorkshops.length > 0
+        ? accessibleWorkshops
+        : availableWorkshops.filter((w) => w.hasAccess !== false);
+    if (selectableWorkshops.length === 0) {
         console.log(chalk.gray('No additional workshops to set up right now (either none found, none accessible, or already downloaded).\n'));
         return;
     }
     console.log();
-    console.log(chalk.bold.cyan('Available Workshops You Have Access To\n'));
+    const header = accessibleWorkshops.length > 0
+        ? 'Available Workshops You Have Access To\n'
+        : 'Available Workshops\n';
+    console.log(chalk.bold.cyan(header));
     console.log(chalk.gray('Icon Key:'));
     console.log(chalk.gray(`  🚀 EpicReact.dev`));
     console.log(chalk.gray(`  🌌 EpicWeb.dev`));
     console.log(chalk.gray(`  ⚡ EpicAI.pro`));
     console.log(chalk.gray(`  🔑 You have access to this workshop`));
     console.log();
+    if (accessibleWorkshops.length === 0) {
+        console.log(chalk.yellow('💡 We could not confirm access for available workshops. You can still select them to try setup.'));
+        console.log(chalk.gray(`   To verify access, log in with: ${chalk.cyan('npx epicshop auth')}`));
+        console.log();
+    }
     // Filter workshops that are part of a product (for "All My Workshops" option)
-    const workshopsWithProduct = candidates.filter((w) => w.productSlug);
+    const workshopsWithProduct = accessibleWorkshops.filter((w) => w.productSlug);
     // Group workshops by product for quick-select options
     const workshopsByProduct = new Map();
     for (const w of workshopsWithProduct) {
@@ -1934,11 +2171,11 @@ async function promptAndSetupAccessibleWorkshops() {
     }
     else {
         // Show checkbox for individual selection
-        const individualChoices = candidates.map((w) => {
+        const individualChoices = selectableWorkshops.map((w) => {
             const productIcon = w.productHost
                 ? PRODUCT_ICONS[w.productHost] || ''
                 : '';
-            const accessIcon = chalk.yellow('🔑');
+            const accessIcon = w.hasAccess === true ? chalk.yellow('🔑') : '';
             const name = [productIcon, w.title || w.name, accessIcon]
                 .filter(Boolean)
                 .join(' ');
@@ -1966,7 +2203,7 @@ async function promptAndSetupAccessibleWorkshops() {
     }
     // Create a map from repo name to workshop title for nice display
     const repoToTitle = new Map();
-    for (const w of candidates) {
+    for (const w of selectableWorkshops) {
         repoToTitle.set(w.name, w.title || w.name);
     }
     const getDisplayName = (repo) => repoToTitle.get(repo) || repo;

package/package.json

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