@epic-web/workshop-utils 6.71.4 → 6.72.1

package/dist/apps.server.d.ts

@@ -2101,7 +2101,7 @@ export declare function getWorkshopInstructions({ request, }?: {
         readonly status: "success";
         readonly code: string;
         readonly title: string | null;
-        readonly epicVideoEmbeds: Array<string>;
+        readonly epicVideoEmbeds: string[];
     } | {
         readonly status: "error";
         readonly error: string;
@@ -2116,7 +2116,7 @@ export declare function getExtrasInstructions({ request, }?: {
         readonly status: "success";
         readonly code: string;
         readonly title: string | null;
-        readonly epicVideoEmbeds: Array<string>;
+        readonly epicVideoEmbeds: string[];
     } | {
         readonly status: "error";
         readonly error: string;
@@ -2131,7 +2131,7 @@ export declare function getWorkshopFinished({ request, }?: {
         readonly status: "success";
         readonly code: string;
         readonly title: string | null;
-        readonly epicVideoEmbeds: Array<string>;
+        readonly epicVideoEmbeds: string[];
     } | {
         readonly status: "error";
         readonly error: string;

package/dist/apps.server.js

@@ -217,6 +217,7 @@ async function isDirectoryEmpty(dirPath) {
         cache: directoryEmptyCache,
         ttl: 1000 * 60 * 5,
         swr: 1000 * 60 * 20,
+        checkValue: z.boolean(),
         forceFresh: await getForceFreshForDir(directoryEmptyCache.get(dirPath), dirPath),
         getFreshValue: async () => {
             try {
@@ -767,6 +768,7 @@ export async function getPlaygroundApp({ timings, request, } = {}) {
         cache: playgroundAppCache,
         ttl: 1000 * 60 * 5,
         swr: 1000 * 60 * 60 * 24 * 30,
+        checkValue: PlaygroundAppSchema.nullable(),
         timings,
         timingKey: playgroundDir.replace(`${playgroundDir}${path.sep}`, ''),
         request,
@@ -892,6 +894,7 @@ async function getExtraApps({ timings, request, } = {}) {
             cache: extraAppCache,
             ttl: 1000 * 60 * 5,
             swr: 1000 * 60 * 60 * 24 * 30,
+            checkValue: ExtraAppSchema.nullable(),
             timings,
             timingKey: extraDir.replace(`${extraDirInfo.fullPath}${path.sep}`, ''),
             request,
@@ -964,6 +967,7 @@ async function getSolutionApps({ timings, request, } = {}) {
             request,
             ttl: 1000 * 60 * 5,
             swr: 1000 * 60 * 60 * 24 * 30,
+            checkValue: SolutionAppSchema.nullable(),
             forceFresh: await getForceFreshForDir(solutionAppCache.get(solutionDir), solutionDir),
             getFreshValue: async () => {
                 return getSolutionAppFromPath(solutionDir, request).catch((error) => {
@@ -1034,6 +1038,7 @@ async function getProblemApps({ timings, request, } = {}) {
             request,
             ttl: 1000 * 60 * 5,
             swr: 1000 * 60 * 60 * 24 * 30,
+            checkValue: ProblemAppSchema.nullable(),
             forceFresh: await getForceFreshForDir(problemAppCache.get(problemDir), problemDir, solutionDir),
             getFreshValue: async () => {
                 return getProblemAppFromPath(problemDir).catch((error) => {

package/dist/cache.server.d.ts

@@ -2,6 +2,18 @@ import * as C from '@epic-web/cachified';
 import { type CreateReporter } from '@epic-web/cachified';
 import z from 'zod';
 import { type Timings } from "./timing.server.js";
+type DiffStatus = 'renamed' | 'modified' | 'deleted' | 'added' | 'unknown';
+type DiffFile = {
+    status: DiffStatus;
+    path: string;
+    line: number;
+};
+type CompiledCodeResult = {
+    outputFiles?: Array<unknown>;
+    errors: Array<unknown>;
+    warnings: Array<unknown>;
+};
+type OgCacheValue = string | Uint8Array;
 /**
  * Creates a cachified reporter that integrates with the Epic Workshop logger system.
  * Uses the pattern `epic:cache:{name-of-cache}` for logger namespaces.
@@ -156,24 +168,24 @@ export declare const playgroundAppCache: C.Cache<{
     epicVideoEmbeds?: string[] | undefined;
 }>;
 export declare const diffCodeCache: C.Cache<string>;
-export declare const diffFilesCache: C.Cache<string>;
+export declare const diffFilesCache: C.Cache<DiffFile[]>;
 export declare const copyUnignoredFilesCache: {
     name: string;
-    set: (key: string, value: C.CacheEntry<string>) => C.CacheEntry<string>;
-    get: (key: string) => C.CacheEntry<string> | undefined;
+    set: (key: string, value: C.CacheEntry<boolean>) => C.CacheEntry<boolean>;
+    get: (key: string) => C.CacheEntry<boolean> | undefined;
     delete: (key: string) => boolean;
 };
 export declare const compiledMarkdownCache: C.Cache<string>;
 export declare const compiledCodeCache: {
     name: string;
-    set: (key: string, value: C.CacheEntry<string>) => C.CacheEntry<string>;
-    get: (key: string) => C.CacheEntry<string> | undefined;
+    set: (key: string, value: C.CacheEntry<CompiledCodeResult>) => C.CacheEntry<CompiledCodeResult>;
+    get: (key: string) => C.CacheEntry<CompiledCodeResult> | undefined;
     delete: (key: string) => boolean;
 };
 export declare const ogCache: {
     name: string;
-    set: (key: string, value: C.CacheEntry<string>) => C.CacheEntry<string>;
-    get: (key: string) => C.CacheEntry<string> | undefined;
+    set: (key: string, value: C.CacheEntry<OgCacheValue>) => C.CacheEntry<OgCacheValue>;
+    get: (key: string) => C.CacheEntry<OgCacheValue> | undefined;
     delete: (key: string) => boolean;
 };
 export declare const compiledInstructionMarkdownCache: C.Cache<{
@@ -197,20 +209,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;
 };
@@ -412,3 +442,4 @@ export declare function shouldForceFresh({ forceFresh, request, key, }: {
     request?: Request;
     key?: string;
 }): Promise<boolean>;
+export {};

package/dist/compile-mdx.server.d.ts

@@ -7,6 +7,6 @@ export declare function compileMdx(file: string, { request, timings, forceFresh,
 }): Promise<{
     code: string;
     title: string | null;
-    epicVideoEmbeds: Array<string>;
+    epicVideoEmbeds: string[];
 }>;
 export declare function compileMarkdownString(markdownString: string): Promise<string>;

package/dist/compile-mdx.server.js

@@ -11,10 +11,16 @@ import rehypeAutolinkHeadings from 'rehype-autolink-headings';
 import emoji from 'remark-emoji';
 import gfm from 'remark-gfm';
 import { visit } from 'unist-util-visit';
+import { z } from 'zod';
 import { cachified, compiledInstructionMarkdownCache, compiledMarkdownCache, shouldForceFresh, } from "./cache.server.js";
 import { checkConnection } from "./utils.server.js";
 const themeCookieName = 'EpicShop_theme';
 const themeHintCookieName = 'EpicShop_CH-prefers-color-scheme';
+const CompiledInstructionMarkdownSchema = z.object({
+    code: z.string(),
+    title: z.string().nullable(),
+    epicVideoEmbeds: z.array(z.string()),
+});
 function getMermaidTheme(request) {
     if (!request)
         return 'default';
@@ -182,6 +188,7 @@ export async function compileMdx(file, { request, timings, forceFresh, } = {}) {
         request,
         timings,
         forceFresh,
+        checkValue: CompiledInstructionMarkdownSchema,
         getFreshValue: () => compileMdxImpl(file, { mermaidTheme }),
     });
 }
@@ -277,6 +284,7 @@ export async function compileMarkdownString(markdownString) {
         key: md5(markdownString),
         cache: compiledMarkdownCache,
         ttl: 1000 * 60 * 60 * 24,
+        checkValue: z.string(),
         getFreshValue: async () => {
             try {
                 verboseLog(`Compiling string`, markdownString);

package/dist/diff.server.d.ts

@@ -5,7 +5,7 @@ export declare function getDiffFiles(app1: App, app2: App, { forceFresh, timings
     timings?: Timings;
     request?: Request;
 }): Promise<{
-    status: "renamed" | "modified" | "deleted" | "added" | "unknown";
+    status: "unknown" | "renamed" | "modified" | "deleted" | "added";
     path: string;
     line: number;
 }[]>;

package/dist/diff.server.js

@@ -7,6 +7,7 @@ import fsExtra from 'fs-extra';
 import ignore from 'ignore';
 import parseGitDiff from 'parse-git-diff';
 import { bundledLanguagesInfo } from 'shiki/langs';
+import { z } from 'zod';
 import { getForceFreshForDir, getRelativePath, getWorkshopRoot, modifiedTimes, } from "./apps.server.js";
 import { cachified, copyUnignoredFilesCache, diffCodeCache, diffFilesCache, } from "./cache.server.js";
 import { compileMarkdownString } from "./compile-mdx.server.js";
@@ -14,6 +15,37 @@ import { modifiedMoreRecentlyThan } from "./modified-time.server.js";
 const epicshopTempDir = path.join(os.tmpdir(), 'epicshop');
 const isDeployed = getEnv().EPICSHOP_DEPLOYED;
 const diffTmpDir = path.join(epicshopTempDir, 'diff');
+const DiffStatusSchema = z.enum([
+    'renamed',
+    'modified',
+    'deleted',
+    'added',
+    'unknown',
+]);
+const DiffFileSchema = z.object({
+    status: DiffStatusSchema,
+    path: z.string(),
+    line: z.number(),
+});
+function getDiffStatus(fileType) {
+    switch (fileType) {
+        case 'ChangedFile': {
+            return 'modified';
+        }
+        case 'AddedFile': {
+            return 'added';
+        }
+        case 'DeletedFile': {
+            return 'deleted';
+        }
+        case 'RenamedFile': {
+            return 'renamed';
+        }
+        default: {
+            return 'unknown';
+        }
+    }
+}
 /**
  * Converts a diff file path to a relative path for display and lookup.
  * - Removes leading/trailing quotes.
@@ -165,6 +197,7 @@ async function copyUnignoredFiles(srcDir, destDir, ignoreList) {
     await cachified({
         key,
         cache: copyUnignoredFilesCache,
+        checkValue: z.boolean(),
         forceFresh: await getForceFreshForDir(copyUnignoredFilesCache.get(key), srcDir),
         async getFreshValue() {
             // @ts-ignore 🤷‍♂️ weird module stuff
@@ -177,6 +210,7 @@ async function copyUnignoredFiles(srcDir, destDir, ignoreList) {
                     return !ig.ignores(path.relative(srcDir, file));
                 },
             });
+            return true;
         },
     });
 }
@@ -266,6 +300,7 @@ export async function getDiffFiles(app1, app2, { forceFresh, timings, request, }
         forceFresh: forceFresh || (await getForceFreshForDiff(app1, app2, cacheEntry)),
         timings,
         request,
+        checkValue: DiffFileSchema.array(),
         getFreshValue: () => getDiffFilesImpl(app1, app2),
     });
     return result;
@@ -288,12 +323,6 @@ async function getDiffFilesImpl(app1, app2) {
     ], { cwd: diffTmpDir }).catch((e) => e);
     void fsExtra.remove(app1CopyPath).catch(() => { });
     void fsExtra.remove(app2CopyPath).catch(() => { });
-    const typesMap = {
-        ChangedFile: 'modified',
-        AddedFile: 'added',
-        DeletedFile: 'deleted',
-        RenamedFile: 'renamed',
-    };
     const parsed = parseGitDiff(diffOutput, { noPrefix: true });
     const testFiles = Array.from(new Set([...getAppTestFiles(app1), ...getAppTestFiles(app2)]));
     const startLine = (file) => {
@@ -309,8 +338,7 @@ async function getDiffFilesImpl(app1, app2) {
     };
     return parsed.files
         .map((file) => ({
-        // prettier-ignore
-        status: (typesMap[file.type] ?? 'unknown'),
+        status: getDiffStatus(file.type),
         path: diffPathToRelative(file.type === 'RenamedFile' ? file.pathBefore : file.path),
         line: startLine(file),
     }))
@@ -325,6 +353,7 @@ export async function getDiffCode(app1, app2, { forceFresh, timings, request, }
         forceFresh: forceFresh || (await getForceFreshForDiff(app1, app2, cacheEntry)),
         timings,
         request,
+        checkValue: z.string(),
         getFreshValue: () => getDiffCodeImpl(app1, app2),
     });
     return result;

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,64 +55,39 @@ 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;
-}>;
-export declare function checkForUpdatesCached(): Promise<{
-    readonly updatesAvailable: false;
-    readonly message: "The app is deployed";
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-    readonly localCommit?: undefined;
-    readonly remoteCommit?: undefined;
-    readonly diffLink?: undefined;
-} | {
-    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: 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: 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 commitsAhead: number;
-    readonly commitsBehind: number;
-    readonly localCommit: string;
-    readonly remoteCommit: string;
-    readonly diffLink: string | null;
+    readonly repoUpdatesAvailable: boolean;
+    readonly dependenciesNeedInstall: boolean;
+    readonly updateNotificationId: string | null;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
     readonly message: null;
+}>;
+export declare function checkForUpdatesCached(): Promise<{
+    updatesAvailable: boolean;
+    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;
 } | {
     readonly updatesAvailable: false;
-    readonly localCommit: string | undefined;
-    readonly remoteCommit: string | undefined;
-    readonly diffLink: string | null;
-    readonly message?: undefined;
-    readonly commitsAhead?: undefined;
-    readonly commitsBehind?: undefined;
-} | {
-    readonly updatesAvailable: false;
+    readonly repoUpdatesAvailable: false;
+    readonly dependenciesNeedInstall: false;
+    readonly updateNotificationId: null;
+    readonly commitsAhead: null;
+    readonly commitsBehind: null;
+    readonly localCommit: null;
+    readonly remoteCommit: null;
+    readonly diffLink: null;
+    readonly message: "The app is deployed";
 }>;
 export declare function updateLocalRepo(): Promise<{
     readonly status: "success";
@@ -107,7 +97,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

@@ -2,20 +2,39 @@ import "./init-env.js";
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { execa, execaCommand } from 'execa';
+import { z } from 'zod';
 import { getWorkshopRoot } from "./apps.server.js";
 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');
+const CheckForUpdatesSchema = z.object({
+    updatesAvailable: z.boolean(),
+    repoUpdatesAvailable: z.boolean(),
+    dependenciesNeedInstall: z.boolean(),
+    updateNotificationId: z.string().nullable(),
+    commitsAhead: z.number().nullable(),
+    commitsBehind: z.number().nullable(),
+    localCommit: z.string().nullable(),
+    remoteCommit: z.string().nullable(),
+    diffLink: z.string().nullable(),
+    message: z.string().nullable(),
+});
 function dirHasTrackedFiles(cwd, dirPath) {
     return execa('git', ['ls-files', dirPath], { cwd }).then((s) => s.stdout.trim().length > 0, () => true);
 }
 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 +81,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 +132,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,21 +165,33 @@ 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({
         ttl: 1000 * 60,
         swr: 1000 * 60 * 60 * 24,
         key,
+        checkValue: CheckForUpdatesSchema,
         getFreshValue: checkForUpdates,
         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 +221,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/modified-time.server.js

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { isGitIgnored } from 'globby';
 import PQueue from 'p-queue';
+import { z } from 'zod';
 import { cachified, dirModifiedTimeCache } from "./cache.server.js";
 async function getDirModifiedTime(dir, { forceFresh = false } = {}) {
     const result = await cachified({
@@ -10,6 +11,7 @@ async function getDirModifiedTime(dir, { forceFresh = false } = {}) {
         cache: dirModifiedTimeCache,
         ttl: 200,
         forceFresh,
+        checkValue: z.number(),
         getFreshValue: () => getDirModifiedTimeImpl(dir),
     });
     return result;

package/dist/notifications.server.js

@@ -22,6 +22,21 @@ const NotificationSchema = z.object({
         .nullable()
         .transform((val) => (val ? new Date(val) : null)),
 });
+// Schema for validating cached notifications (post-transform, with Date objects)
+const CachedNotificationSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    message: z.string(),
+    link: z.string().optional(),
+    type: z.enum(['info', 'warning', 'danger']),
+    products: z
+        .array(z.object({
+        host: z.string(),
+        slug: z.string().optional(),
+    }))
+        .optional(),
+    expiresAt: z.instanceof(Date).nullable(),
+});
 async function getRemoteNotifications() {
     return cachified({
         key: 'notifications',
@@ -29,6 +44,7 @@ async function getRemoteNotifications() {
         ttl: 1000 * 60 * 60 * 6,
         swr: 1000 * 60 * 60 * 24,
         offlineFallbackValue: [],
+        checkValue: CachedNotificationSchema.array(),
         async getFreshValue() {
             const URL = 'https://gist.github.com/kentcdodds/c3aaa5141f591cdbb0e6bfcacd361f39';
             const filename = 'notifications.json5';

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/dist/utils.server.js

@@ -1,4 +1,5 @@
 import "./init-env.js";
+import { z } from 'zod';
 import { cachified, connectionCache } from "./cache.server.js";
 import { logger } from "./logger.js";
 export { dayjs } from "./utils.js";
@@ -42,6 +43,7 @@ export async function checkConnection({ request, timings, } = {}) {
         timings,
         key: 'connected',
         ttl: 1000 * 10,
+        checkValue: z.boolean(),
         async getFreshValue(context) {
             connectionLog('getting fresh connection value');
             const isOnline = await raceConnectivity();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epic-web/workshop-utils",
-  "version": "6.71.4",
+  "version": "6.72.1",
   "publishConfig": {
     "access": "public"
   },
@@ -191,7 +191,7 @@
     "@mdx-js/mdx": "^3.1.1",
     "@playwright/test": "^1.57.0",
     "@react-router/node": "^7.12.0",
-    "@sentry/react-router": "^10.35.0",
+    "@sentry/react-router": "^10.36.0",
     "@testing-library/dom": "^10.4.1",
     "@testing-library/jest-dom": "^6.9.1",
     "@total-typescript/ts-reset": "^0.6.1",
@@ -221,7 +221,7 @@
     "mdx-bundler": "^10.1.1",
     "p-queue": "^9.1.0",
     "parse-git-diff": "^0.0.19",
-    "pkgmgr": "^1.0.0",
+    "pkgmgr": "^1.1.1",
     "react": "^19.2.3",
     "react-dom": "^19.2.3",
     "react-router": "^7.12.0",
@@ -241,7 +241,7 @@
     "@types/hast": "^3.0.4",
     "@types/mdast": "^4.0.4",
     "@types/node": "^25.0.9",
-    "@types/react": "^19.2.8",
+    "@types/react": "^19.2.9",
     "@types/react-dom": "^19.2.3",
     "@types/shell-quote": "^1.7.5",
     "vitest": "^4.0.17",