@epic-web/workshop-utils 6.71.3 → 6.72.0

package/dist/cache.server.d.ts

@@ -197,20 +197,38 @@ export declare const checkForUpdatesCache: {
     name: string;
     set: (key: string, value: C.CacheEntry<{
         updatesAvailable: boolean;
-        localCommit: string;
-        remoteCommit: string;
+        repoUpdatesAvailable: boolean;
+        dependenciesNeedInstall: boolean;
+        updateNotificationId: string | null;
+        commitsAhead: number | null;
+        commitsBehind: number | null;
+        localCommit: string | null;
+        remoteCommit: string | null;
         diffLink: string | null;
+        message: string | null;
     }>) => C.CacheEntry<{
         updatesAvailable: boolean;
-        localCommit: string;
-        remoteCommit: string;
+        repoUpdatesAvailable: boolean;
+        dependenciesNeedInstall: boolean;
+        updateNotificationId: string | null;
+        commitsAhead: number | null;
+        commitsBehind: number | null;
+        localCommit: string | null;
+        remoteCommit: string | null;
         diffLink: string | null;
+        message: string | null;
     }>;
     get: (key: string) => C.CacheEntry<{
         updatesAvailable: boolean;
-        localCommit: string;
-        remoteCommit: string;
+        repoUpdatesAvailable: boolean;
+        dependenciesNeedInstall: boolean;
+        updateNotificationId: string | null;
+        commitsAhead: number | null;
+        commitsBehind: number | null;
+        localCommit: string | null;
+        remoteCommit: string | null;
         diffLink: string | null;
+        message: string | null;
     }> | undefined;
     delete: (key: string) => boolean;
 };

package/dist/env.server.d.ts

@@ -10,6 +10,7 @@ declare const schema: z.ZodPipe<z.ZodObject<{
     EPICSHOP_GITHUB_REPO: z.ZodDefault<z.ZodString>;
     EPICSHOP_GITHUB_ROOT: z.ZodDefault<z.ZodString>;
     EPICSHOP_APP_VERSION: z.ZodOptional<z.ZodString>;
+    EPICSHOP_APP_COMMIT_SHA: z.ZodOptional<z.ZodString>;
     EPICSHOP_PARENT_PORT: z.ZodOptional<z.ZodString>;
     EPICSHOP_PARENT_TOKEN: z.ZodOptional<z.ZodString>;
     EPICSHOP_APP_LOCATION: z.ZodOptional<z.ZodString>;
@@ -19,6 +20,7 @@ declare const schema: z.ZodPipe<z.ZodObject<{
     SENTRY_ORG: z.ZodDefault<z.ZodString>;
     SENTRY_PROJECT: z.ZodDefault<z.ZodString>;
     SENTRY_PROJECT_ID: z.ZodDefault<z.ZodString>;
+    SENTRY_RELEASE: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodTransform<{
     EPICSHOP_CONTEXT_CWD: string;
     EPICSHOP_WORKSHOP_INSTANCE_ID: string;
@@ -32,9 +34,11 @@ declare const schema: z.ZodPipe<z.ZodObject<{
     SENTRY_PROJECT: string;
     SENTRY_PROJECT_ID: string;
     EPICSHOP_APP_VERSION?: string | undefined;
+    EPICSHOP_APP_COMMIT_SHA?: string | undefined;
     EPICSHOP_PARENT_PORT?: string | undefined;
     EPICSHOP_PARENT_TOKEN?: string | undefined;
     EPICSHOP_APP_LOCATION?: string | undefined;
+    SENTRY_RELEASE?: string | undefined;
 }, {
     EPICSHOP_CONTEXT_CWD: string;
     EPICSHOP_WORKSHOP_INSTANCE_ID: string;
@@ -48,9 +52,11 @@ declare const schema: z.ZodPipe<z.ZodObject<{
     SENTRY_PROJECT: string;
     SENTRY_PROJECT_ID: string;
     EPICSHOP_APP_VERSION?: string | undefined;
+    EPICSHOP_APP_COMMIT_SHA?: string | undefined;
     EPICSHOP_PARENT_PORT?: string | undefined;
     EPICSHOP_PARENT_TOKEN?: string | undefined;
     EPICSHOP_APP_LOCATION?: string | undefined;
+    SENTRY_RELEASE?: string | undefined;
 }>>;
 declare global {
     namespace NodeJS {
@@ -76,11 +82,13 @@ export declare function getEnv(): {
     EPICSHOP_GITHUB_ROOT: string;
     EPICSHOP_DEPLOYED: boolean;
     EPICSHOP_APP_VERSION: string | undefined;
+    EPICSHOP_APP_COMMIT_SHA: string | undefined;
     EPICSHOP_PARENT_PORT: string | undefined;
     EPICSHOP_PARENT_TOKEN: string | undefined;
     EPICSHOP_IS_PUBLISHED: boolean;
     SENTRY_DSN: string;
     SENTRY_PROJECT_ID: string;
+    SENTRY_RELEASE: string | undefined;
 };
 type ENV = ReturnType<typeof getEnv>;
 declare global {

package/dist/env.server.js

@@ -16,6 +16,7 @@ const schema = z
     EPICSHOP_GITHUB_REPO: z.string().default(''),
     EPICSHOP_GITHUB_ROOT: z.string().default(''),
     EPICSHOP_APP_VERSION: z.string().optional(),
+    EPICSHOP_APP_COMMIT_SHA: z.string().optional(),
     EPICSHOP_PARENT_PORT: z.string().optional(),
     EPICSHOP_PARENT_TOKEN: z.string().optional(),
     EPICSHOP_APP_LOCATION: z.string().optional(),
@@ -30,6 +31,7 @@ const schema = z
     SENTRY_ORG: z.string().default('kent-c-dodds-tech-llc'),
     SENTRY_PROJECT: z.string().default('epicshop'),
     SENTRY_PROJECT_ID: z.string().default('4509630082252800'),
+    SENTRY_RELEASE: z.string().optional(),
 })
     .transform(async (env) => {
     if (env.EPICSHOP_CONTEXT_CWD === '') {
@@ -122,10 +124,12 @@ export function getEnv() {
         EPICSHOP_DEPLOYED: process.env.EPICSHOP_DEPLOYED === 'true' ||
             process.env.EPICSHOP_DEPLOYED === '1',
         EPICSHOP_APP_VERSION: process.env.EPICSHOP_APP_VERSION,
+        EPICSHOP_APP_COMMIT_SHA: process.env.EPICSHOP_APP_COMMIT_SHA,
         EPICSHOP_PARENT_PORT: process.env.EPICSHOP_PARENT_PORT,
         EPICSHOP_PARENT_TOKEN: process.env.EPICSHOP_PARENT_TOKEN,
         EPICSHOP_IS_PUBLISHED: process.env.EPICSHOP_IS_PUBLISHED === 'true',
         SENTRY_DSN: process.env.SENTRY_DSN,
         SENTRY_PROJECT_ID: process.env.SENTRY_PROJECT_ID,
+        SENTRY_RELEASE: process.env.SENTRY_RELEASE,
     };
 }

package/dist/git.server.d.ts

@@ -1,38 +1,53 @@
 import "./init-env.js";
 export declare function checkForUpdates(): Promise<{
     readonly updatesAvailable: false;
+    readonly dependenciesNeedInstall: false;
+    readonly updateNotificationId: null;
     readonly message: "The app is deployed";
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-    readonly localCommit?: undefined;
-    readonly remoteCommit?: undefined;
-    readonly diffLink?: undefined;
+    readonly repoUpdatesAvailable: boolean;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly localCommit: null;
+    readonly remoteCommit: null;
+    readonly diffLink: null;
 } | {
-    readonly updatesAvailable: false;
     readonly message: "You are offline";
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-    readonly localCommit?: undefined;
-    readonly remoteCommit?: undefined;
-    readonly diffLink?: undefined;
+    readonly updatesAvailable: boolean;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly localCommit: null;
+    readonly remoteCommit: null;
+    readonly diffLink: null;
 } | {
-    readonly updatesAvailable: false;
     readonly message: "Not in a git repo";
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-    readonly localCommit?: undefined;
-    readonly remoteCommit?: undefined;
-    readonly diffLink?: undefined;
+    readonly updatesAvailable: boolean;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly localCommit: null;
+    readonly remoteCommit: null;
+    readonly diffLink: null;
 } | {
-    readonly updatesAvailable: false;
     readonly message: "Cannot find remote";
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-    readonly localCommit?: undefined;
-    readonly remoteCommit?: undefined;
-    readonly diffLink?: undefined;
+    readonly updatesAvailable: boolean;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly localCommit: null;
+    readonly remoteCommit: null;
+    readonly diffLink: null;
 } | {
     readonly updatesAvailable: boolean;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
     readonly commitsAhead: number;
     readonly commitsBehind: number;
     readonly localCommit: string;
@@ -40,48 +55,66 @@ export declare function checkForUpdates(): Promise<{
     readonly diffLink: string | null;
     readonly message: null;
 } | {
-    readonly updatesAvailable: false;
-    readonly localCommit: string | undefined;
-    readonly remoteCommit: string | undefined;
+    readonly localCommit: string | null;
+    readonly remoteCommit: string | null;
     readonly diffLink: string | null;
-    readonly message?: undefined;
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
+    readonly updatesAvailable: boolean;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly message: null;
 }>;
 export declare function checkForUpdatesCached(): Promise<{
     readonly updatesAvailable: false;
+    readonly dependenciesNeedInstall: false;
+    readonly updateNotificationId: null;
     readonly message: "The app is deployed";
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-    readonly localCommit?: undefined;
-    readonly remoteCommit?: undefined;
-    readonly diffLink?: undefined;
+    readonly repoUpdatesAvailable: boolean;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly localCommit: null;
+    readonly remoteCommit: null;
+    readonly diffLink: null;
 } | {
-    readonly updatesAvailable: false;
     readonly message: "You are offline";
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-    readonly localCommit?: undefined;
-    readonly remoteCommit?: undefined;
-    readonly diffLink?: undefined;
+    readonly updatesAvailable: boolean;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly localCommit: null;
+    readonly remoteCommit: null;
+    readonly diffLink: null;
 } | {
-    readonly updatesAvailable: false;
     readonly message: "Not in a git repo";
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-    readonly localCommit?: undefined;
-    readonly remoteCommit?: undefined;
-    readonly diffLink?: undefined;
+    readonly updatesAvailable: boolean;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly localCommit: null;
+    readonly remoteCommit: null;
+    readonly diffLink: null;
 } | {
-    readonly updatesAvailable: false;
     readonly message: "Cannot find remote";
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-    readonly localCommit?: undefined;
-    readonly remoteCommit?: undefined;
-    readonly diffLink?: undefined;
+    readonly updatesAvailable: boolean;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly localCommit: null;
+    readonly remoteCommit: null;
+    readonly diffLink: null;
 } | {
     readonly updatesAvailable: boolean;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
     readonly commitsAhead: number;
     readonly commitsBehind: number;
     readonly localCommit: string;
@@ -89,15 +122,16 @@ export declare function checkForUpdatesCached(): Promise<{
     readonly diffLink: string | null;
     readonly message: null;
 } | {
-    readonly updatesAvailable: false;
-    readonly localCommit: string | undefined;
-    readonly remoteCommit: string | undefined;
+    readonly localCommit: string | null;
+    readonly remoteCommit: string | null;
     readonly diffLink: string | null;
-    readonly message?: undefined;
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-} | {
-    readonly updatesAvailable: false;
+    readonly updatesAvailable: boolean;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly message: null;
 }>;
 export declare function updateLocalRepo(): Promise<{
     readonly status: "success";
@@ -107,7 +141,7 @@ export declare function updateLocalRepo(): Promise<{
     readonly message: string;
 } | {
     readonly status: "success";
-    readonly message: "Updated successfully.";
+    readonly message: "Updated successfully." | "Dependencies updated successfully.";
 }>;
 export declare function getCommitInfo(): Promise<{
     hash: string;

package/dist/git.server.js

@@ -7,6 +7,7 @@ import { cachified, checkForUpdatesCache } from "./cache.server.js";
 import { getWorkshopConfig } from "./config.server.js";
 import { getEnv } from "./env.server.js";
 import { logger } from "./logger.js";
+import { getInstallCommand, getWorkspaceInstallStatus, } from "./package-install/package-install-check.server.js";
 import { checkConnection } from "./utils.server.js";
 import { getErrorMessage } from "./utils.js";
 const gitLog = logger('epic:git');
@@ -16,6 +17,11 @@ function dirHasTrackedFiles(cwd, dirPath) {
 function isDirectory(dirPath) {
     return fs.stat(dirPath).then((s) => s.isDirectory(), () => false);
 }
+function getDependencyNotificationId(dependencyHash) {
+    if (!dependencyHash)
+        return null;
+    return `update-deps-${dependencyHash}`;
+}
 async function cleanupEmptyExerciseDirectories(cwd) {
     console.log('🧹 Cleaning up empty exercise directories...');
     try {
@@ -62,25 +68,48 @@ async function getDiffUrl(commitBefore, commitAfter) {
 }
 export async function checkForUpdates() {
     const ENV = getEnv();
+    const cwd = getWorkshopRoot();
+    const dependencyStatus = await getWorkspaceInstallStatus(cwd);
+    const dependencyNotificationId = dependencyStatus.dependenciesNeedInstall
+        ? getDependencyNotificationId(dependencyStatus.dependencyHash)
+        : null;
+    const baseResult = {
+        updatesAvailable: dependencyStatus.dependenciesNeedInstall,
+        repoUpdatesAvailable: false,
+        dependenciesNeedInstall: dependencyStatus.dependenciesNeedInstall,
+        updateNotificationId: dependencyNotificationId,
+        commitsAhead: null,
+        commitsBehind: null,
+        localCommit: null,
+        remoteCommit: null,
+        diffLink: null,
+        message: null,
+    };
     if (ENV.EPICSHOP_DEPLOYED) {
-        return { updatesAvailable: false, message: 'The app is deployed' };
+        return {
+            ...baseResult,
+            updatesAvailable: false,
+            dependenciesNeedInstall: false,
+            updateNotificationId: null,
+            message: 'The app is deployed',
+        };
     }
-    const cwd = getWorkshopRoot();
     const online = await checkConnection();
     if (!online) {
-        return { updatesAvailable: false, message: 'You are offline' };
+        return { ...baseResult, message: 'You are offline' };
     }
     const isInRepo = await execaCommand('git rev-parse --is-inside-work-tree', {
         cwd,
     }).then(() => true, () => false);
     if (!isInRepo) {
-        return { updatesAvailable: false, message: 'Not in a git repo' };
+        return { ...baseResult, message: 'Not in a git repo' };
     }
     const { stdout: remote } = await execaCommand('git remote', { cwd });
     if (!remote) {
-        return { updatesAvailable: false, message: 'Cannot find remote' };
+        return { ...baseResult, message: 'Cannot find remote' };
     }
-    let localCommit, remoteCommit;
+    let localCommit = null;
+    let remoteCommit = null;
     try {
         const currentBranch = (await execaCommand('git rev-parse --abbrev-ref HEAD', { cwd })).stdout.trim();
         localCommit = (await execaCommand('git rev-parse --short HEAD', { cwd })).stdout.trim();
@@ -90,21 +119,28 @@ export async function checkForUpdates() {
         })).stdout.trim();
         const { stdout } = await execa('git', ['rev-list', '--count', '--left-right', 'HEAD...@{upstream}'], { cwd });
         const [ahead = 0, behind = 0] = stdout.trim().split(/\s+/).map(Number);
-        const updatesAvailable = behind > 0;
+        const repoUpdatesAvailable = behind > 0;
+        const updatesAvailable = repoUpdatesAvailable || dependencyStatus.dependenciesNeedInstall;
+        const updateNotificationId = repoUpdatesAvailable
+            ? `update-repo-${remoteCommit}`
+            : dependencyNotificationId;
         return {
             updatesAvailable,
+            repoUpdatesAvailable,
+            dependenciesNeedInstall: dependencyStatus.dependenciesNeedInstall,
+            updateNotificationId,
             commitsAhead: ahead,
             commitsBehind: behind,
             localCommit,
             remoteCommit,
             diffLink: await getDiffUrl(localCommit, remoteCommit),
-            message: null,
+            message: baseResult.message,
         };
     }
     catch (error) {
         console.error('Unable to check for updates', getErrorMessage(error));
         return {
-            updatesAvailable: false,
+            ...baseResult,
             localCommit,
             remoteCommit,
             diffLink: localCommit && remoteCommit
@@ -116,7 +152,18 @@ export async function checkForUpdates() {
 export async function checkForUpdatesCached() {
     const ENV = getEnv();
     if (ENV.EPICSHOP_DEPLOYED) {
-        return { updatesAvailable: false };
+        return {
+            updatesAvailable: false,
+            repoUpdatesAvailable: false,
+            dependenciesNeedInstall: false,
+            updateNotificationId: null,
+            commitsAhead: null,
+            commitsBehind: null,
+            localCommit: null,
+            remoteCommit: null,
+            diffLink: null,
+            message: 'The app is deployed',
+        };
     }
     const key = 'checkForUpdates';
     return cachified({
@@ -127,10 +174,10 @@ export async function checkForUpdatesCached() {
         cache: checkForUpdatesCache,
     });
 }
-async function runNpmInstallWithRetry(cwd, maxRetries = 3, baseDelayMs = 1000) {
+async function runInstallWithRetry(cwd, command, args, maxRetries = 3, baseDelayMs = 1000) {
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
         try {
-            await execaCommand('npm install', { cwd, stdio: 'inherit' });
+            await execa(command, args, { cwd, stdio: 'inherit' });
             return;
         }
         catch (error) {
@@ -160,49 +207,77 @@ export async function updateLocalRepo() {
     const cwd = getWorkshopRoot();
     try {
         const updates = await checkForUpdates();
-        if (!updates.updatesAvailable) {
+        const repoUpdatesAvailable = updates.repoUpdatesAvailable;
+        let dependencyStatus = await getWorkspaceInstallStatus(cwd);
+        let rootsNeedingInstall = dependencyStatus.roots.filter((status) => status.dependenciesNeedInstall);
+        if (!repoUpdatesAvailable && rootsNeedingInstall.length === 0) {
             return {
                 status: 'success',
                 message: updates.message ?? 'No updates available.',
             };
         }
-        const uncommittedChanges = (await execaCommand('git status --porcelain', { cwd })).stdout.trim()
-            .length > 0;
-        if (uncommittedChanges) {
-            console.log('👜 Stashing uncommitted changes...');
-            await execaCommand('git stash --include-untracked', { cwd });
+        let didPull = false;
+        let didInstall = false;
+        if (repoUpdatesAvailable) {
+            const uncommittedChanges = (await execaCommand('git status --porcelain', { cwd })).stdout.trim()
+                .length > 0;
+            if (uncommittedChanges) {
+                console.log('👜 Stashing uncommitted changes...');
+                await execaCommand('git stash --include-untracked', { cwd });
+            }
+            console.log('⬇️ Pulling latest changes...');
+            await execaCommand('git pull origin HEAD', { cwd });
+            if (uncommittedChanges) {
+                console.log('👜 re-applying stashed changes...');
+                await execaCommand('git stash pop', { cwd });
+            }
+            didPull = true;
+            dependencyStatus = await getWorkspaceInstallStatus(cwd);
+            rootsNeedingInstall = dependencyStatus.roots.filter((status) => status.dependenciesNeedInstall);
         }
-        console.log('⬇️ Pulling latest changes...');
-        await execaCommand('git pull origin HEAD', { cwd });
-        if (uncommittedChanges) {
-            console.log('👜 re-applying stashed changes...');
-            await execaCommand('git stash pop', { cwd });
+        if (rootsNeedingInstall.length > 0) {
+            for (const root of rootsNeedingInstall) {
+                const rootLabel = path.relative(cwd, root.rootDir).replace(/\\/g, '/') || '.';
+                const { command, args } = getInstallCommand(root.packageManager);
+                const commandLabel = `${command} ${args.join(' ')}`.trim();
+                console.log(`📦 Installing dependencies in ${rootLabel} using ${commandLabel}...`);
+                try {
+                    await runInstallWithRetry(root.rootDir, command, args);
+                    didInstall = true;
+                }
+                catch (error) {
+                    const isEbusy = error instanceof Error &&
+                        (error.message.includes('EBUSY') ||
+                            error.code === 'EBUSY');
+                    if (isEbusy) {
+                        return {
+                            status: 'error',
+                            message: `${commandLabel} failed: files are locked. ` +
+                                'Please close any editors or terminals using this directory, ' +
+                                `then run: ${commandLabel}`,
+                        };
+                    }
+                    throw error;
+                }
+            }
         }
-        console.log('📦 Re-installing dependencies...');
-        try {
-            await runNpmInstallWithRetry(cwd);
+        else if (repoUpdatesAvailable) {
+            console.log('📦 Dependencies already match package.json. Skipping install.');
         }
-        catch (error) {
-            const isEbusy = error instanceof Error &&
-                (error.message.includes('EBUSY') ||
-                    error.code === 'EBUSY');
-            if (isEbusy) {
-                return {
-                    status: 'error',
-                    message: 'npm install failed: files are locked. ' +
-                        'Please close any editors or terminals using this directory, ' +
-                        'then run: npm install',
-                };
+        if (didPull || didInstall) {
+            await cleanupEmptyExerciseDirectories(cwd);
+            const postUpdateScript = getWorkshopConfig().scripts?.postupdate;
+            if (postUpdateScript) {
+                console.log('🏃 Running post update script...');
+                await execaCommand(postUpdateScript, { cwd, stdio: 'inherit' });
             }
-            throw error;
         }
-        await cleanupEmptyExerciseDirectories(cwd);
-        const postUpdateScript = getWorkshopConfig().scripts?.postupdate;
-        if (postUpdateScript) {
-            console.log('🏃 Running post update script...');
-            await execaCommand(postUpdateScript, { cwd, stdio: 'inherit' });
-        }
-        return { status: 'success', message: 'Updated successfully.' };
+        return {
+            status: 'success',
+            message: repoUpdatesAvailable
+                ? 'Updated successfully.'
+                : 'Dependencies updated successfully.',
+        };
     }
     catch (error) {
         return { status: 'error', message: getErrorMessage(error) };

package/dist/offline-videos.server.d.ts

@@ -75,6 +75,7 @@ export declare function getOfflineVideoDownloadState(): OfflineVideoDownloadStat
 export declare function getOfflineVideoSummary({ request, }?: {
     request?: Request;
 }): Promise<OfflineVideoSummary>;
+export declare function getOfflineVideoPlaybackIds(): Promise<Array<string> | null>;
 export declare function warmOfflineVideoSummary(): Promise<void>;
 export declare function startOfflineVideoDownload({ request, }?: {
     request?: Request;

package/dist/offline-videos.server.js

@@ -563,6 +563,39 @@ export async function getOfflineVideoSummary({ request, } = {}) {
         downloadState,
     };
 }
+export async function getOfflineVideoPlaybackIds() {
+    try {
+        const workshop = getWorkshopIdentity();
+        const keyInfo = await getOfflineVideoKeyInfo({
+            userId: null,
+            allowUserIdUpdate: false,
+        });
+        if (!keyInfo)
+            return [];
+        const index = await readOfflineVideoIndex();
+        const playbackIds = [];
+        for (const [playbackId, entry] of Object.entries(index)) {
+            if (entry.status !== 'ready')
+                continue;
+            if (entry.keyId !== keyInfo.keyId)
+                continue;
+            if (entry.cryptoVersion !== keyInfo.config.version)
+                continue;
+            if (!hasWorkshop(entry, workshop.id))
+                continue;
+            if (typeof entry.size === 'number' && entry.size <= 0)
+                continue;
+            playbackIds.push(playbackId);
+        }
+        return playbackIds;
+    }
+    catch (error) {
+        log.warn('Failed to load offline video playback ids', {
+            error: formatDownloadError(error),
+        });
+        return null;
+    }
+}
 export async function warmOfflineVideoSummary() {
     await getWorkshopVideoCollection();
 }

package/dist/package-install/package-install-check.server.d.ts

@@ -0,0 +1,23 @@
+export type RootPackageInstallStatus = {
+    rootDir: string;
+    packageJsonPath: string;
+    packageManager: string | null;
+    dependencyHash: string | null;
+    dependenciesNeedInstall: boolean;
+    missingDependencies: Array<string>;
+    missingDevDependencies: Array<string>;
+    missingOptionalDependencies: Array<string>;
+    reason: 'missing-node-modules' | 'missing-dependencies' | 'package-json-unreadable' | 'up-to-date';
+};
+export type WorkspaceInstallStatus = {
+    roots: Array<RootPackageInstallStatus>;
+    dependenciesNeedInstall: boolean;
+    dependencyHash: string | null;
+};
+export declare function getRootPackageJsonPaths(cwd: string): Promise<string[]>;
+export declare function getRootPackageInstallStatus(packageJsonPath: string): Promise<RootPackageInstallStatus>;
+export declare function getWorkspaceInstallStatus(cwd: string): Promise<WorkspaceInstallStatus>;
+export declare function getInstallCommand(packageManager: string | null): {
+    command: string;
+    args: string[];
+};

package/dist/package-install/package-install-check.server.js

@@ -0,0 +1,229 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { globby } from 'globby';
+import { getErrorMessage } from "../utils.js";
+const workspaceIgnorePatterns = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/.cache/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/coverage/**',
+];
+function hashString(value) {
+    return createHash('sha256').update(value).digest('hex').slice(0, 8);
+}
+function normalizeDependencyMap(dependencies) {
+    const entries = Object.entries(dependencies ?? {}).sort(([a], [b]) => a.localeCompare(b));
+    return Object.fromEntries(entries);
+}
+function getDependencySnapshot(packageJson) {
+    return {
+        dependencies: normalizeDependencyMap(packageJson.dependencies),
+        devDependencies: normalizeDependencyMap(packageJson.devDependencies),
+        optionalDependencies: normalizeDependencyMap(packageJson.optionalDependencies),
+    };
+}
+function parsePackageManager(value) {
+    if (!value)
+        return null;
+    const [name] = value.split('@');
+    return name || null;
+}
+function normalizeWorkspacePattern(pattern) {
+    const trimmed = pattern.trim();
+    if (!trimmed)
+        return trimmed;
+    const isNegated = trimmed.startsWith('!');
+    const raw = isNegated ? trimmed.slice(1) : trimmed;
+    const normalized = raw.replace(/\\/g, '/');
+    const withPackageJson = normalized.endsWith('package.json')
+        ? normalized
+        : path.posix.join(normalized, 'package.json');
+    return isNegated ? `!${withPackageJson}` : withPackageJson;
+}
+async function readPackageJson(filePath) {
+    try {
+        const contents = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(contents);
+    }
+    catch (error) {
+        console.warn(`⚠️  Failed to read package.json at ${filePath}:`, getErrorMessage(error));
+        return null;
+    }
+}
+async function getWorkspacePackageJsonPaths(packageJsonPath) {
+    const packageJson = await readPackageJson(packageJsonPath);
+    if (!packageJson)
+        return [];
+    const workspaces = Array.isArray(packageJson.workspaces)
+        ? packageJson.workspaces
+        : (packageJson.workspaces?.packages ?? []);
+    if (!workspaces.length)
+        return [];
+    const workspacePatterns = workspaces.map(normalizeWorkspacePattern);
+    return globby(workspacePatterns, {
+        cwd: path.dirname(packageJsonPath),
+        absolute: true,
+        ignore: workspaceIgnorePatterns,
+    });
+}
+async function listPackageJsonPaths(cwd) {
+    return globby('**/package.json', {
+        cwd,
+        absolute: true,
+        ignore: workspaceIgnorePatterns,
+    });
+}
+async function listInstalledPackages(nodeModulesPath) {
+    try {
+        const entries = await fs.readdir(nodeModulesPath, { withFileTypes: true });
+        const packages = new Set();
+        for (const entry of entries) {
+            if (entry.name.startsWith('.'))
+                continue;
+            if (entry.name.startsWith('@')) {
+                if (!entry.isDirectory())
+                    continue;
+                const scopePath = path.join(nodeModulesPath, entry.name);
+                const scopeEntries = await fs.readdir(scopePath, {
+                    withFileTypes: true,
+                });
+                for (const scopedEntry of scopeEntries) {
+                    if (scopedEntry.name.startsWith('.'))
+                        continue;
+                    if (scopedEntry.isDirectory() || scopedEntry.isSymbolicLink()) {
+                        packages.add(`${entry.name}/${scopedEntry.name}`);
+                    }
+                }
+                continue;
+            }
+            if (entry.isDirectory() || entry.isSymbolicLink()) {
+                packages.add(entry.name);
+            }
+        }
+        return packages;
+    }
+    catch {
+        return null;
+    }
+}
+function getExpectedDependencies(dependencies) {
+    return Object.keys(dependencies ?? {}).sort();
+}
+export async function getRootPackageJsonPaths(cwd) {
+    const allPackageJsonPaths = await listPackageJsonPaths(cwd);
+    const workspacePackageJsonPaths = new Set();
+    for (const packageJsonPath of allPackageJsonPaths) {
+        const workspacePaths = await getWorkspacePackageJsonPaths(packageJsonPath);
+        for (const workspacePath of workspacePaths) {
+            workspacePackageJsonPaths.add(path.resolve(workspacePath));
+        }
+    }
+    return allPackageJsonPaths
+        .map((packageJsonPath) => path.resolve(packageJsonPath))
+        .filter((packageJsonPath) => !workspacePackageJsonPaths.has(packageJsonPath))
+        .sort();
+}
+export async function getRootPackageInstallStatus(packageJsonPath) {
+    const rootDir = path.dirname(packageJsonPath);
+    const packageJson = await readPackageJson(packageJsonPath);
+    if (!packageJson) {
+        return {
+            rootDir,
+            packageJsonPath,
+            packageManager: null,
+            dependencyHash: null,
+            dependenciesNeedInstall: false,
+            missingDependencies: [],
+            missingDevDependencies: [],
+            missingOptionalDependencies: [],
+            reason: 'package-json-unreadable',
+        };
+    }
+    const dependencySnapshot = getDependencySnapshot(packageJson);
+    const dependencyHash = hashString(JSON.stringify(dependencySnapshot));
+    const packageManager = parsePackageManager(packageJson.packageManager);
+    const dependencies = getExpectedDependencies(packageJson.dependencies);
+    const devDependencies = getExpectedDependencies(packageJson.devDependencies);
+    const optionalDependencies = getExpectedDependencies(packageJson.optionalDependencies);
+    const expectedDependencies = [
+        ...dependencies,
+        ...devDependencies,
+        ...optionalDependencies,
+    ];
+    if (expectedDependencies.length === 0) {
+        return {
+            rootDir,
+            packageJsonPath,
+            packageManager,
+            dependencyHash,
+            dependenciesNeedInstall: false,
+            missingDependencies: [],
+            missingDevDependencies: [],
+            missingOptionalDependencies: [],
+            reason: 'up-to-date',
+        };
+    }
+    const installedPackages = await listInstalledPackages(path.join(rootDir, 'node_modules'));
+    if (!installedPackages) {
+        return {
+            rootDir,
+            packageJsonPath,
+            packageManager,
+            dependencyHash,
+            dependenciesNeedInstall: true,
+            missingDependencies: dependencies,
+            missingDevDependencies: devDependencies,
+            missingOptionalDependencies: optionalDependencies,
+            reason: 'missing-node-modules',
+        };
+    }
+    const missingDependencies = dependencies.filter((dep) => !installedPackages.has(dep));
+    const missingDevDependencies = devDependencies.filter((dep) => !installedPackages.has(dep));
+    const missingOptionalDependencies = optionalDependencies.filter((dep) => !installedPackages.has(dep));
+    const dependenciesNeedInstall = missingDependencies.length > 0 || missingDevDependencies.length > 0;
+    return {
+        rootDir,
+        packageJsonPath,
+        packageManager,
+        dependencyHash,
+        dependenciesNeedInstall,
+        missingDependencies,
+        missingDevDependencies,
+        missingOptionalDependencies,
+        reason: dependenciesNeedInstall ? 'missing-dependencies' : 'up-to-date',
+    };
+}
+export async function getWorkspaceInstallStatus(cwd) {
+    const rootPackageJsonPaths = await getRootPackageJsonPaths(cwd);
+    const rootStatuses = await Promise.all(rootPackageJsonPaths.map(getRootPackageInstallStatus));
+    const dependenciesNeedInstall = rootStatuses.some((status) => status.dependenciesNeedInstall);
+    const dependencyHash = rootStatuses.length > 0
+        ? hashString(JSON.stringify(rootStatuses
+            .map((status) => ({
+            path: path.relative(cwd, status.packageJsonPath),
+            hash: status.dependencyHash,
+        }))
+            .sort((a, b) => a.path.localeCompare(b.path))))
+        : null;
+    return {
+        roots: rootStatuses,
+        dependenciesNeedInstall,
+        dependencyHash,
+    };
+}
+export function getInstallCommand(packageManager) {
+    switch (packageManager) {
+        case 'pnpm':
+            return { command: 'pnpm', args: ['install'] };
+        case 'yarn':
+            return { command: 'yarn', args: ['install'] };
+        case 'bun':
+            return { command: 'bun', args: ['install'] };
+        case 'npm':
+        default:
+            return { command: 'npm', args: ['install'] };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epic-web/workshop-utils",
-  "version": "6.71.3",
+  "version": "6.72.0",
   "publishConfig": {
     "access": "public"
   },