epicshop 6.66.0 → 6.68.0

package/dist/cli.js

@@ -1,13 +1,17 @@
 #!/usr/bin/env node
 import '@epic-web/workshop-utils/init-env';
+import { PACKAGE_MANAGERS, getPackageManager, isPackageManagerConfigured, setPackageManager, } from '@epic-web/workshop-utils/workshops.server';
 import chalk from 'chalk';
 import { matchSorter } from 'match-sorter';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { assertCanPrompt } from "./utils/cli-runtime.js";
+import { assertCanPrompt, hasTty, isCiEnvironment, } from "./utils/cli-runtime.js";
+import { detectRuntimePackageManager } from "./utils/package-manager.js";
+import { initCliSentry } from "./utils/sentry-cli.js";
 // Check for --help on start command before yargs parses
 // (yargs exits before command handler when help is requested)
 const args = hideBin(process.argv);
+const cliSentry = initCliSentry(args);
 if ((args.includes('--help') || args.includes('-h')) &&
     (args.length === 0 || args[0] === 'start')) {
     const { displayHelp } = await import("./commands/start.js");
@@ -26,6 +30,43 @@ function formatHelp(helpText) {
         .replace(/--[\w-]+/g, (match) => chalk.yellow(match))
         .replace(/-\w(?=\s|,)/g, (match) => chalk.yellow(match));
 }
+async function maybePromptToUpdatePackageManager(parsedArgs) {
+    if (parsedArgs.includes('--help') || parsedArgs.includes('-h'))
+        return;
+    if (parsedArgs.includes('--silent') || parsedArgs.includes('-s'))
+        return;
+    if (parsedArgs[0] === 'config')
+        return;
+    if (isCiEnvironment() || !hasTty())
+        return;
+    const runtimeManager = detectRuntimePackageManager();
+    if (!runtimeManager)
+        return;
+    const isConfigured = await isPackageManagerConfigured();
+    if (!isConfigured)
+        return;
+    const configuredManager = await getPackageManager();
+    if (configuredManager === runtimeManager)
+        return;
+    const { confirm } = await import('@inquirer/prompts');
+    const shouldUpdate = await confirm({
+        message: `You ran epicshop with ${runtimeManager}, but your default package manager is ${configuredManager}. Update the default?`,
+        default: true,
+    });
+    if (shouldUpdate) {
+        await setPackageManager(runtimeManager);
+        console.log(chalk.green(`✅ Default package manager updated to ${runtimeManager}.`));
+    }
+}
+try {
+    await maybePromptToUpdatePackageManager(args);
+}
+catch (error) {
+    if (error.message === 'USER_QUIT') {
+        process.exit(0);
+    }
+    // Silently ignore other errors during package manager prompt to avoid disrupting CLI startup
+}
 // Set up yargs CLI
 const cli = yargs(args)
     .scriptName('epicshop')
@@ -34,6 +75,9 @@ const cli = yargs(args)
     .alias('h', 'help')
     .version(false)
     .showHelpOnFail(true)
+    .middleware((argv) => {
+    cliSentry.setCommandContextFromArgv(argv);
+})
     .command('start [workshop]', 'Start a workshop (auto-detects if inside a workshop directory)', (yargs) => {
     return yargs
         .positional('workshop', {
@@ -133,6 +177,22 @@ const cli = yargs(args)
     if (!result.success) {
         process.exit(1);
     }
+})
+    .command('setup', 'Install workshop dependencies (uses configured package manager)', (yargs) => {
+    return yargs
+        .option('silent', {
+        alias: 's',
+        type: 'boolean',
+        description: 'Run without output logs',
+        default: false,
+    })
+        .example('$0 setup', 'Install workshop dependencies');
+}, async (argv) => {
+    const { setup } = await import("./commands/setup.js");
+    const result = await setup({ silent: argv.silent });
+    if (!result.success) {
+        process.exit(1);
+    }
 })
     .command('add [repo-name] [destination]', 'Add a workshop by cloning from epicweb-dev GitHub org', (yargs) => {
     return yargs
@@ -263,6 +323,11 @@ const cli = yargs(args)
         .option('repos-dir', {
         type: 'string',
         description: 'Set the default directory for workshop repos',
+    })
+        .option('package-manager', {
+        type: 'string',
+        choices: PACKAGE_MANAGERS,
+        description: 'Set the default package manager',
     })
         .option('silent', {
         alias: 's',
@@ -278,6 +343,7 @@ const cli = yargs(args)
     const result = await config({
         subcommand: argv.subcommand === 'reset' ? 'reset' : undefined,
         reposDir: argv.reposDir,
+        packageManager: argv.packageManager,
         silent: argv.silent,
     });
     if (!result.success) {
@@ -663,6 +729,12 @@ const cli = yargs(args)
             throw error;
         }
     }
+    if (!argv.subcommand) {
+        cliSentry.setCommandContext({
+            command: 'auth',
+            subcommand,
+        });
+    }
     let result;
     switch (subcommand) {
         case 'status':
@@ -1120,6 +1192,10 @@ try {
             name: `${chalk.green('add')} - Add a workshop`,
             value: 'add',
             description: 'Clone a workshop from epicweb-dev GitHub org',
+        }, {
+            name: `${chalk.green('setup')} - Install dependencies`,
+            value: 'setup',
+            description: 'Install workshop dependencies (uses configured manager)',
         }, {
             name: `${chalk.green('remove')} - Remove a workshop`,
             value: 'remove',
@@ -1172,6 +1248,7 @@ try {
                 });
             },
         });
+        cliSentry.setCommandContext({ command: subcommand, interactive: true });
         switch (subcommand) {
             case 'start': {
                 const { findWorkshopRoot, startWorkshop } = await import("./commands/workshops.js");
@@ -1227,6 +1304,13 @@ try {
                     process.exit(1);
                 break;
             }
+            case 'setup': {
+                const { setup } = await import("./commands/setup.js");
+                const result = await setup({});
+                if (!result.success)
+                    process.exit(1);
+                break;
+            }
             case 'remove': {
                 const { findWorkshopRoot, remove } = await import("./commands/workshops.js");
                 const workshopRoot = await findWorkshopRoot();
@@ -1421,6 +1505,10 @@ try {
                         });
                     },
                 });
+                cliSentry.setCommandContext({
+                    command: 'auth',
+                    subcommand: authSubcommand,
+                });
                 let authResult;
                 switch (authSubcommand) {
                     case 'status':
@@ -1532,6 +1620,8 @@ catch (error) {
     if (error.message === 'USER_QUIT') {
         process.exit(0);
     }
+    cliSentry.captureException(error);
+    await cliSentry.flush();
     console.error(chalk.red('❌ Error:'), error);
     process.exit(1);
 }

package/dist/commands/setup.d.ts

@@ -0,0 +1,10 @@
+export type SetupOptions = {
+    cwd?: string;
+    silent?: boolean;
+};
+export type SetupResult = {
+    success: boolean;
+    message?: string;
+    error?: Error;
+};
+export declare function setup(options?: SetupOptions): Promise<SetupResult>;

package/dist/commands/setup.js

@@ -0,0 +1,136 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getErrorMessage } from '@epic-web/workshop-utils/utils';
+import { getPackageManager, isPackageManagerConfigured, } from '@epic-web/workshop-utils/workshops.server';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import { resolveCliCommand, runCommand, } from "../utils/command-runner.js";
+import { formatPackageManagerCommand, getPackageManagerInstallArgs, getPackageManagerRunArgs, } from "../utils/package-manager.js";
+function isPackageJson(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    if (!('scripts' in value))
+        return true;
+    const scriptsValue = value.scripts;
+    if (scriptsValue === undefined)
+        return true;
+    if (!scriptsValue || typeof scriptsValue !== 'object')
+        return false;
+    return Object.values(scriptsValue).every((script) => typeof script === 'string');
+}
+async function getPackageManagerVersion(packageManager) {
+    try {
+        const result = await execa(resolveCliCommand(packageManager), ['--version'], {
+            stdio: 'pipe',
+        });
+        return { success: true, version: result.stdout.trim() };
+    }
+    catch (error) {
+        const message = getErrorMessage(error, 'Failed to check package manager');
+        const err = error instanceof Error ? error : new Error(message);
+        return { success: false, error: err };
+    }
+}
+function isNpmVersionSupported(version) {
+    const [majorString, minorString] = version.split('.');
+    const major = Number(majorString);
+    const minor = Number(minorString);
+    if (!Number.isFinite(major) || !Number.isFinite(minor))
+        return false;
+    return major > 8 || (major === 8 && minor >= 16);
+}
+function formatCommandResultError(result, fallbackMessage) {
+    return {
+        success: false,
+        message: result.message ?? fallbackMessage,
+        error: result.error,
+    };
+}
+export async function setup(options = {}) {
+    const { silent = false } = options;
+    const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+    const packageJsonPath = path.join(cwd, 'package.json');
+    try {
+        await fs.promises.access(packageJsonPath);
+    }
+    catch {
+        const message = `package.json not found at ${packageJsonPath}`;
+        if (!silent) {
+            console.error(chalk.red(`❌ ${message}`));
+        }
+        return { success: false, message, error: new Error(message) };
+    }
+    let scripts;
+    try {
+        const parsed = JSON.parse(await fs.promises.readFile(packageJsonPath, 'utf8'));
+        if (isPackageJson(parsed)) {
+            scripts = parsed.scripts;
+        }
+    }
+    catch (error) {
+        const message = getErrorMessage(error, 'Failed to read package.json');
+        if (!silent) {
+            console.error(chalk.red(`❌ ${message}`));
+        }
+        return { success: false, message, error: error };
+    }
+    const packageManager = await getPackageManager();
+    const isConfigured = await isPackageManagerConfigured();
+    const managerLabel = isConfigured
+        ? packageManager
+        : `${packageManager} (default)`;
+    const versionResult = await getPackageManagerVersion(packageManager);
+    if (!versionResult.success || !versionResult.version) {
+        const message = `Failed to run ${packageManager} --version. Please ensure ${packageManager} is installed.`;
+        if (!silent) {
+            console.error(chalk.red(`❌ ${message}`));
+        }
+        return {
+            success: false,
+            message,
+            error: versionResult.error ?? new Error(message),
+        };
+    }
+    if (packageManager === 'npm' &&
+        !isNpmVersionSupported(versionResult.version)) {
+        const message = `npm version is ${versionResult.version} which is out of date. Please install npm@8.16.0 or greater.`;
+        if (!silent) {
+            console.error(chalk.red(`❌ ${message}`));
+        }
+        return { success: false, message, error: new Error(message) };
+    }
+    const installArgs = getPackageManagerInstallArgs(packageManager);
+    const installCommand = formatPackageManagerCommand(packageManager, installArgs);
+    if (!silent) {
+        console.log(chalk.cyan(`📦 Installing dependencies using ${chalk.bold(managerLabel)}...`));
+        console.log(chalk.gray(`   To change this, run: npx epicshop config --package-manager <npm|pnpm|yarn|bun>`));
+        console.log(chalk.gray(`   Running: ${installCommand}`));
+    }
+    const installResult = await runCommand(packageManager, installArgs, {
+        cwd,
+        silent,
+    });
+    if (!installResult.success) {
+        return formatCommandResultError(installResult, 'Failed to install dependencies');
+    }
+    const hasCustomSetup = Boolean(scripts?.['setup:custom']);
+    if (hasCustomSetup) {
+        const customArgs = getPackageManagerRunArgs(packageManager, 'setup:custom');
+        const customCommand = formatPackageManagerCommand(packageManager, customArgs);
+        if (!silent) {
+            console.log(chalk.cyan(`🔧 Running ${customCommand}...`));
+        }
+        const customResult = await runCommand(packageManager, customArgs, {
+            cwd,
+            silent,
+        });
+        if (!customResult.success) {
+            return formatCommandResultError(customResult, 'Failed to run setup:custom');
+        }
+    }
+    const message = 'Workshop setup complete';
+    if (!silent) {
+        console.log(chalk.green(`✅ ${message}`));
+    }
+    return { success: true, message };
+}

package/dist/commands/workshops.d.ts

@@ -1,4 +1,5 @@
 import '@epic-web/workshop-utils/init-env';
+import { type PackageManager } from '@epic-web/workshop-utils/workshops.server';
 /**
  * Find the workshop root directory by walking up from the current directory
  * looking for a package.json with an epicshop field.
@@ -27,6 +28,7 @@ export type StartOptions = {
 };
 export type ConfigOptions = {
     reposDir?: string;
+    packageManager?: PackageManager;
     silent?: boolean;
     subcommand?: 'reset' | 'delete';
 };

package/dist/commands/workshops.js

@@ -6,12 +6,14 @@ import { cachified, githubCache } from '@epic-web/workshop-utils/cache.server';
 import { parseEpicshopConfig } from '@epic-web/workshop-utils/config.server';
 import { getAuthInfo } from '@epic-web/workshop-utils/db.server';
 import { userHasAccessToWorkshop } from '@epic-web/workshop-utils/epic-api.server';
-import { getErrorMessage } from '@epic-web/workshop-utils/utils';
+import { PACKAGE_MANAGERS, clearPackageManager, getPackageManager, isPackageManagerConfigured, setPackageManager, } from '@epic-web/workshop-utils/workshops.server';
 import chalk from 'chalk';
-import { execa } from 'execa';
 import { matchSorter, rankings } from 'match-sorter';
 import ora from 'ora';
 import { assertCanPrompt, isCiEnvironment } from "../utils/cli-runtime.js";
+import { runCommand, runCommandInteractive } from "../utils/command-runner.js";
+import { formatPackageManagerCommand, getPackageManagerRunArgs, } from "../utils/package-manager.js";
+import { setup } from "./setup.js";
 const GITHUB_ORG = 'epicweb-dev';
 const TUTORIAL_REPO = 'epicshop-tutorial';
 const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
@@ -343,14 +345,7 @@ async function addSingleWorkshop(repoName, options) {
             error: cloneResult.error,
         };
     }
-    if (!silent) {
-        console.log(chalk.cyan(`🔧 Running npm run setup...`));
-    }
-    // Run npm run setup
-    const setupResult = await runCommand('npm', ['run', 'setup'], {
-        cwd: workshopPath,
-        silent,
-    });
+    const setupResult = await setup({ cwd: workshopPath, silent });
     if (!setupResult.success) {
         // Clean up the cloned directory on setup failure
         if (!silent) {
@@ -364,7 +359,7 @@ async function addSingleWorkshop(repoName, options) {
         }
         return {
             success: false,
-            message: `Failed to run setup: ${setupResult.message}`,
+            message: `Failed to set up workshop: ${setupResult.message}`,
             error: setupResult.error,
         };
     }
@@ -794,12 +789,14 @@ export async function list({ silent = false, } = {}) {
                 });
             },
         });
+        const packageManager = await getPackageManager();
+        const startCommand = formatPackageManagerCommand(packageManager, getPackageManagerRunArgs(packageManager, 'start'));
         // Show actions for selected workshop
         const actionChoices = [
             {
                 name: 'Start workshop',
                 value: 'start',
-                description: 'Run npm start in the workshop directory',
+                description: `Run ${startCommand} in the workshop directory`,
             },
             {
                 name: 'Open in editor',
@@ -1084,8 +1081,10 @@ export async function startWorkshop(options = {}) {
             console.log(chalk.cyan(`🚀 Starting ${chalk.bold(workshopToStart.title)}...`));
             console.log(chalk.gray(`   Path: ${workshopToStart.path}\n`));
         }
-        // Run npm start in the workshop directory
-        const startResult = await runCommandInteractive('npm', ['start'], {
+        const packageManager = await getPackageManager();
+        const startArgs = getPackageManagerRunArgs(packageManager, 'start');
+        // Run start script in the workshop directory
+        const startResult = await runCommandInteractive(packageManager, startArgs, {
             cwd: workshopToStart.path,
         });
         if (!startResult.success) {
@@ -1282,14 +1281,27 @@ export async function config(options = {}) {
                 return { success: true, message: 'Cancelled' };
             }
         }
+        // Handle CLI flags for setting config values
+        const messages = [];
         if (options.reposDir) {
             // Set the repos directory directly via CLI flag
             const resolvedPath = path.resolve(options.reposDir);
             await setReposDirectory(resolvedPath);
             const message = `Repos directory set to: ${resolvedPath}`;
+            messages.push(message);
             if (!silent)
                 console.log(chalk.green(`✅ ${message}`));
-            return { success: true, message };
+        }
+        if (options.packageManager) {
+            await setPackageManager(options.packageManager);
+            const message = `Package manager set to: ${options.packageManager}`;
+            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('; ') };
         }
         if (silent) {
             // In silent mode, just return current config
@@ -1301,13 +1313,16 @@ export async function config(options = {}) {
             reason: 'select a configuration option',
             hints: [
                 'Set repos dir directly: npx epicshop config --repos-dir <path>',
+                'Set package manager directly: npx epicshop config --package-manager <npm|pnpm|yarn|bun>',
                 '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 reposDir = await getReposDirectory();
         const isConfigured = await isReposDirectoryConfigured();
         const defaultDir = getDefaultReposDir();
+        const packageManager = await getPackageManager();
+        const isPackageManagerSet = await isPackageManagerConfigured();
         // Build config options
         const configOptions = [
             {
@@ -1315,6 +1330,13 @@ export async function config(options = {}) {
                 value: 'repos-dir',
                 description: isConfigured ? reposDir : `${reposDir} (default)`,
             },
+            {
+                name: `Package manager`,
+                value: 'package-manager',
+                description: isPackageManagerSet
+                    ? packageManager
+                    : `${packageManager} (default)`,
+            },
             {
                 name: `Reset config file`,
                 value: 'reset',
@@ -1433,6 +1455,87 @@ export async function config(options = {}) {
                 return { success: true, message: 'Cancelled' };
             }
         }
+        if (selectedConfig === 'package-manager') {
+            console.log();
+            console.log(chalk.bold('  Current value:'));
+            if (isPackageManagerSet) {
+                console.log(chalk.white(`  ${packageManager}`));
+            }
+            else {
+                console.log(chalk.gray(`  ${packageManager} (default, not explicitly set)`));
+            }
+            console.log();
+            const actionChoices = [
+                {
+                    name: 'Edit',
+                    value: 'edit',
+                    description: 'Change the default package manager',
+                },
+                ...(isPackageManagerSet
+                    ? [
+                        {
+                            name: 'Remove',
+                            value: 'remove',
+                            description: 'Reset to default (npm)',
+                        },
+                    ]
+                    : []),
+                {
+                    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 selectedManager = await select({
+                    message: 'Select a package manager:',
+                    choices: PACKAGE_MANAGERS.map((manager) => ({
+                        name: manager,
+                        value: manager,
+                    })),
+                });
+                await setPackageManager(selectedManager);
+                console.log();
+                console.log(chalk.green(`✅ Package manager set to: ${chalk.bold(selectedManager)}`));
+                return {
+                    success: true,
+                    message: `Package manager set to: ${selectedManager}`,
+                };
+            }
+            else if (action === 'remove') {
+                const shouldRemove = await confirm({
+                    message: 'Reset package manager to default (npm)?',
+                    default: false,
+                });
+                if (shouldRemove) {
+                    await clearPackageManager();
+                    console.log();
+                    console.log(chalk.green(`✅ Package manager reset to default (npm).`));
+                    return {
+                        success: true,
+                        message: 'Package manager reset to default (npm).',
+                    };
+                }
+                else {
+                    console.log(chalk.gray('\nNo changes made.'));
+                    return { success: true, message: 'Cancelled' };
+                }
+            }
+            else {
+                console.log(chalk.gray('\nNo changes made.'));
+                return { success: true, message: 'Cancelled' };
+            }
+        }
         return { success: true, message: 'Config viewed' };
     }
     catch (error) {
@@ -1719,7 +1822,8 @@ async function promptAndSetupAccessibleWorkshops() {
     const { workshopExists } = await import('@epic-web/workshop-utils/workshops.server');
     console.log(chalk.bold.cyan('\n📚 Workshop Setup\n'));
     console.log(chalk.cyan('🐨 Next, you can select any workshops you’d like me to set up for you.'));
-    console.log(chalk.gray('   This will clone each workshop repo into your workshops directory and run `npm run setup`.\n' +
+    const packageManager = await getPackageManager();
+    console.log(chalk.gray(`   This will clone each workshop repo into your workshops directory and run setup using ${packageManager}.\n` +
         '   (If something fails, we’ll keep going and you can retry later with `npx epicshop add`.)\n'));
     assertCanPrompt({
         reason: 'select workshops to set up',
@@ -2000,12 +2104,7 @@ async function ensureTutorialAndStart() {
             error: cloneResult.error,
         };
     }
-    console.log(chalk.cyan(`\n🔧 Running npm run setup...\n`));
-    // Run npm run setup
-    const setupResult = await runCommand('npm', ['run', 'setup'], {
-        cwd: workshopPath,
-        silent: false,
-    });
+    const setupResult = await setup({ cwd: workshopPath, silent: false });
     if (!setupResult.success) {
         // Clean up on failure
         console.log(chalk.yellow(`🧹 Cleaning up cloned directory...`));
@@ -2015,10 +2114,10 @@ async function ensureTutorialAndStart() {
         catch {
             // Ignore cleanup errors
         }
-        console.error(chalk.red(`❌ Failed to run setup: ${setupResult.message}`));
+        console.error(chalk.red(`❌ Failed to set up workshop: ${setupResult.message}`));
         return {
             success: false,
-            message: `Failed to run setup: ${setupResult.message}`,
+            message: `Failed to set up workshop: ${setupResult.message}`,
             error: setupResult.error,
         };
     }
@@ -2033,8 +2132,10 @@ async function ensureTutorialAndStart() {
     }
     await promptToStartTutorial(workshopTitle);
     console.log(chalk.cyan(`\n🚀 Starting ${chalk.bold(workshopTitle)}...\n`));
+    const packageManager = await getPackageManager();
+    const startArgs = getPackageManagerRunArgs(packageManager, 'start');
     // Start the workshop
-    const startResult = await runCommandInteractive('npm', ['start'], {
+    const startResult = await runCommandInteractive(packageManager, startArgs, {
         cwd: workshopPath,
     });
     if (!startResult.success) {
@@ -2200,40 +2301,3 @@ async function directoryExists(dirPath) {
         return false;
     }
 }
-function resolveCliCommand(command) {
-    // On Windows, package manager binaries are typically shimmed as *.cmd files.
-    // Spawning "npm" directly can fail with ENOENT even though "npm.cmd" exists.
-    if (process.platform === 'win32' &&
-        (command === 'npm' || command === 'npx')) {
-        return `${command}.cmd`;
-    }
-    return command;
-}
-function runCommand(command, args, options) {
-    return execa(resolveCliCommand(command), args, {
-        cwd: options.cwd,
-        stdio: options.silent ? 'pipe' : 'inherit',
-    }).then(() => ({ success: true }), (error) => {
-        const message = getErrorMessage(error, 'Command failed');
-        const err = error instanceof Error ? error : new Error(message);
-        return { success: false, message, error: err };
-    });
-}
-function runCommandInteractive(command, args, options) {
-    return execa(resolveCliCommand(command), args, {
-        cwd: options.cwd,
-        stdio: 'inherit',
-    }).then(() => ({ success: true }), (error) => {
-        // If the process was terminated by a signal (e.g. user presses Ctrl+C),
-        // treat it as success so we don't show a confusing error message.
-        if (error &&
-            typeof error === 'object' &&
-            'signal' in error &&
-            typeof error.signal === 'string') {
-            return { success: true };
-        }
-        const message = getErrorMessage(error, 'Command failed');
-        const err = error instanceof Error ? error : new Error(message);
-        return { success: false, message, error: err };
-    });
-}

package/dist/utils/command-runner.d.ts

@@ -0,0 +1,13 @@
+export type CommandResult = {
+    success: boolean;
+    message?: string;
+    error?: Error;
+};
+export declare function resolveCliCommand(command: string): string;
+export declare function runCommand(command: string, args: string[], options: {
+    cwd: string;
+    silent?: boolean;
+}): Promise<CommandResult>;
+export declare function runCommandInteractive(command: string, args: string[], options: {
+    cwd: string;
+}): Promise<CommandResult>;

package/dist/utils/command-runner.js

@@ -0,0 +1,41 @@
+import { getErrorMessage } from '@epic-web/workshop-utils/utils';
+import { execa } from 'execa';
+export function resolveCliCommand(command) {
+    // On Windows, package manager binaries are typically shimmed as *.cmd files.
+    if (process.platform === 'win32' &&
+        (command === 'npm' ||
+            command === 'npx' ||
+            command === 'pnpm' ||
+            command === 'yarn')) {
+        return `${command}.cmd`;
+    }
+    return command;
+}
+export function runCommand(command, args, options) {
+    return execa(resolveCliCommand(command), args, {
+        cwd: options.cwd,
+        stdio: options.silent ? 'pipe' : 'inherit',
+    }).then(() => ({ success: true }), (error) => {
+        const message = getErrorMessage(error, 'Command failed');
+        const err = error instanceof Error ? error : new Error(message);
+        return { success: false, message, error: err };
+    });
+}
+export function runCommandInteractive(command, args, options) {
+    return execa(resolveCliCommand(command), args, {
+        cwd: options.cwd,
+        stdio: 'inherit',
+    }).then(() => ({ success: true }), (error) => {
+        // If the process was terminated by a signal (e.g. user presses Ctrl+C),
+        // treat it as success so we don't show a confusing error message.
+        if (error &&
+            typeof error === 'object' &&
+            'signal' in error &&
+            typeof error.signal === 'string') {
+            return { success: true };
+        }
+        const message = getErrorMessage(error, 'Command failed');
+        const err = error instanceof Error ? error : new Error(message);
+        return { success: false, message, error: err };
+    });
+}

package/dist/utils/package-manager.d.ts

@@ -0,0 +1,5 @@
+import { type PackageManager } from '@epic-web/workshop-utils/workshops.server';
+export declare function detectRuntimePackageManager(): PackageManager | null;
+export declare function getPackageManagerInstallArgs(_packageManager: PackageManager): string[];
+export declare function getPackageManagerRunArgs(_packageManager: PackageManager, script: string): string[];
+export declare function formatPackageManagerCommand(packageManager: PackageManager, args: string[]): string;

package/dist/utils/package-manager.js

@@ -0,0 +1,27 @@
+function detectPackageManager(value) {
+    if (!value)
+        return null;
+    if (value.includes('pnpm'))
+        return 'pnpm';
+    if (value.includes('yarn'))
+        return 'yarn';
+    if (value.includes('bun'))
+        return 'bun';
+    if (value.includes('npm'))
+        return 'npm';
+    return null;
+}
+export function detectRuntimePackageManager() {
+    const userAgent = (process.env.npm_config_user_agent ?? '').toLowerCase();
+    const execPath = (process.env.npm_execpath ?? '').toLowerCase();
+    return detectPackageManager(userAgent) ?? detectPackageManager(execPath);
+}
+export function getPackageManagerInstallArgs(_packageManager) {
+    return ['install'];
+}
+export function getPackageManagerRunArgs(_packageManager, script) {
+    return ['run', script];
+}
+export function formatPackageManagerCommand(packageManager, args) {
+    return `${packageManager} ${args.join(' ')}`.trim();
+}

package/dist/utils/sentry-cli.d.ts

@@ -0,0 +1,18 @@
+type CliCommandContext = {
+    command?: string;
+    subcommand?: string;
+    flags?: string[];
+    interactive?: boolean;
+    help?: boolean;
+};
+type CliSentry = {
+    enabled: boolean;
+    setCommandContext: (update: Partial<CliCommandContext>) => void;
+    setCommandContextFromArgv: (argv: {
+        _: Array<string | number>;
+    }) => void;
+    captureException: (error: unknown) => void;
+    flush: (timeoutMs?: number) => Promise<boolean>;
+};
+export declare function initCliSentry(args: string[]): CliSentry;
+export {};

package/dist/utils/sentry-cli.js

@@ -0,0 +1,135 @@
+import { getEnv } from '@epic-web/workshop-utils/init-env';
+import * as Sentry from '@sentry/node';
+const HELP_FLAGS = new Set(['--help', '-h']);
+function extractFlags(args) {
+    const flags = new Set();
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg || arg === '-' || !arg.startsWith('-')) {
+            continue;
+        }
+        if (arg === '--') {
+            break;
+        }
+        if (arg.startsWith('--')) {
+            const [flag] = arg.split('=');
+            if (flag)
+                flags.add(flag);
+            if (!arg.includes('=') && args[i + 1] && !args[i + 1]?.startsWith('-')) {
+                i += 1;
+            }
+        }
+        else {
+            flags.add(arg);
+            if (arg.length === 2 && args[i + 1] && !args[i + 1]?.startsWith('-')) {
+                i += 1;
+            }
+        }
+    }
+    return Array.from(flags).sort();
+}
+function deriveCommandContext(args) {
+    const interactive = args.length === 0;
+    const doubleDashIndex = args.indexOf('--');
+    const argsBeforeDoubleDash = doubleDashIndex >= 0 ? args.slice(0, doubleDashIndex) : args;
+    const help = argsBeforeDoubleDash.some((arg) => HELP_FLAGS.has(arg));
+    const flags = extractFlags(args);
+    let command;
+    const firstNonFlagIndex = args.findIndex((arg) => !arg.startsWith('-'));
+    if (firstNonFlagIndex >= 0) {
+        command = args[firstNonFlagIndex];
+    }
+    if (!command) {
+        if (help) {
+            command = 'help';
+        }
+        else if (interactive) {
+            command = 'chooser';
+        }
+    }
+    return {
+        command,
+        flags,
+        interactive,
+        help: help || command === 'help',
+    };
+}
+function deriveCommandContextFromArgv(args, argv) {
+    const baseContext = deriveCommandContext(args);
+    const segments = argv._?.map(String).filter(Boolean) ?? [];
+    const command = segments[0] ?? baseContext.command;
+    const hasSubcommand = Object.prototype.hasOwnProperty.call(argv, 'subcommand');
+    const subcommand = hasSubcommand && typeof argv.subcommand === 'string'
+        ? argv.subcommand
+        : baseContext.subcommand;
+    const help = Boolean(argv.help ?? argv.h ?? baseContext.help);
+    return {
+        ...baseContext,
+        command,
+        subcommand,
+        help,
+    };
+}
+function applyCommandContext(context) {
+    Sentry.setTag('cli.command', context.command ?? 'unknown');
+    Sentry.setTag('cli.subcommand', context.subcommand ?? 'none');
+    if (context.interactive !== undefined) {
+        Sentry.setTag('cli.interactive', context.interactive ? 'true' : 'false');
+    }
+    if (context.help !== undefined) {
+        Sentry.setTag('cli.help', context.help ? 'true' : 'false');
+    }
+    Sentry.setContext('cli', {
+        command: context.command ?? 'unknown',
+        subcommand: context.subcommand ?? null,
+        flags: context.flags ?? [],
+        interactive: context.interactive ?? false,
+        help: context.help ?? false,
+        stdin_tty: Boolean(process.stdin.isTTY),
+        stdout_tty: Boolean(process.stdout.isTTY),
+    });
+}
+export function initCliSentry(args) {
+    const env = getEnv();
+    const enabled = env.EPICSHOP_IS_PUBLISHED && Boolean(env.SENTRY_DSN);
+    if (!enabled) {
+        return {
+            enabled,
+            setCommandContext: () => { },
+            setCommandContextFromArgv: () => { },
+            captureException: () => { },
+            flush: async () => true,
+        };
+    }
+    Sentry.init({
+        dsn: env.SENTRY_DSN,
+        sendDefaultPii: false,
+        environment: env.EPICSHOP_IS_PUBLISHED ? 'production' : 'development',
+        tracesSampleRate: 1,
+    });
+    Sentry.setTags({
+        epicshop_github_repo: env.EPICSHOP_GITHUB_REPO || 'unknown',
+        epicshop_workshop_instance_id: env.EPICSHOP_WORKSHOP_INSTANCE_ID || 'unknown',
+        epicshop_app_version: env.EPICSHOP_APP_VERSION || 'unknown',
+        epicshop_published: env.EPICSHOP_IS_PUBLISHED ? 'true' : 'false',
+    });
+    let currentContext = deriveCommandContext(args);
+    applyCommandContext(currentContext);
+    return {
+        enabled,
+        setCommandContext(update) {
+            currentContext = { ...currentContext, ...update };
+            applyCommandContext(currentContext);
+        },
+        setCommandContextFromArgv(argv) {
+            currentContext = deriveCommandContextFromArgv(args, argv);
+            applyCommandContext(currentContext);
+        },
+        captureException(error) {
+            Sentry.captureException(error);
+        },
+        flush(timeoutMs = 2000) {
+            return Sentry.flush(timeoutMs);
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "epicshop",
-  "version": "6.66.0",
+  "version": "6.68.0",
   "publishConfig": {
     "access": "public"
   },
@@ -14,6 +14,7 @@
     "exports": {
       "./package.json": "./package.json",
       "./cleanup": "./src/commands/cleanup.ts",
+      "./setup": "./src/commands/setup.ts",
       "./warm": "./src/commands/warm.ts",
       "./start": "./src/commands/start.ts",
       "./update": "./src/commands/update.ts",
@@ -33,6 +34,11 @@
       "types": "./dist/commands/cleanup.d.ts",
       "default": "./dist/commands/cleanup.js"
     },
+    "./setup": {
+      "import": "./dist/commands/setup.js",
+      "types": "./dist/commands/setup.d.ts",
+      "default": "./dist/commands/setup.js"
+    },
     "./warm": {
       "import": "./dist/commands/warm.js",
       "types": "./dist/commands/warm.d.ts",
@@ -93,15 +99,16 @@
     "build:watch": "nx watch --projects=epicshop -- nx run \\$NX_PROJECT_NAME:build"
   },
   "dependencies": {
-    "@epic-web/workshop-utils": "6.66.0",
+    "@epic-web/workshop-utils": "6.68.0",
     "@inquirer/prompts": "^8.2.0",
+    "@sentry/node": "^10.35.0",
     "chalk": "^5.6.2",
     "close-with-grace": "^2.4.0",
     "execa": "^9.6.1",
     "get-port": "^7.1.0",
     "match-sorter": "^8.2.0",
-    "openid-client": "^6.8.1",
     "open": "^11.0.0",
+    "openid-client": "^6.8.1",
     "ora": "^9.0.0",
     "yargs": "^18.0.0"
   },
@@ -109,8 +116,8 @@
     "@epic-web/config": "^1.21.3",
     "@types/node": "^25.0.9",
     "@types/yargs": "^17.0.35",
-    "zshy": "^0.7.0",
-    "vitest": "^4.0.17"
+    "vitest": "^4.0.17",
+    "zshy": "^0.7.0"
   },
   "repository": {
     "type": "git",