@superblocksteam/sdk 2.0.123 → 2.0.124-next.1

package/dist/cli-replacement/dependency-install-classifier.test.mjs

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "vitest";
+import { InitialInstallFailed, classifyInitialInstallError, } from "./dependency-install-classifier.mjs";
+const ERESOLVE_JSON = JSON.stringify({
+    error: {
+        code: "ERESOLVE",
+        summary: "unable to resolve dependency tree",
+        detail: 'Found: react-router@undefined\nCould not resolve dependency:\npeer react-router@">=6.4" from @superblocksteam/library@2.0.0-SNAPSHOT',
+    },
+});
+describe("classifyInitialInstallError", () => {
+    it("classifies ERESOLVE as dependency_conflict and extracts packages", () => {
+        const e = classifyInitialInstallError({
+            stdout: ERESOLVE_JSON,
+            stderr: "npm error code ERESOLVE",
+            message: "Command failed",
+        }, { hasAnyRegistryConfigured: true, requestedPackages: [] });
+        expect(e.type).toBe("dev-server/dependency-install");
+        expect(e.category).toBe("dependency_conflict");
+        expect(e.npmErrorCode).toBe("ERESOLVE");
+        expect(e.packages?.some((p) => p.name === "react-router")).toBe(true);
+        expect(e.rawError.length).toBeGreaterThan(0);
+    });
+    it("maps an E404 registry block to not_in_registry", () => {
+        const E404 = JSON.stringify({
+            error: {
+                code: "E404",
+                summary: "Not Found - GET https://reg.corp/foo",
+                detail: "'foo@1.0.0' is not in this registry.",
+            },
+        });
+        const e = classifyInitialInstallError({ stdout: E404, stderr: "", message: "x" }, { hasAnyRegistryConfigured: true, requestedPackages: [{ name: "foo" }] });
+        expect(e.category).toBe("not_in_registry");
+        expect(e.registryHost).toBe("reg.corp");
+    });
+    it("falls back to unknown for an unmapped code (still a DependencyInstallError)", () => {
+        const e = classifyInitialInstallError({
+            stdout: "not json",
+            stderr: "npm error code EWEIRD\nsomething broke",
+            message: "x",
+        }, {});
+        expect(e.category).toBe("unknown");
+        expect(e.rawError).toContain("EWEIRD");
+    });
+    it("InitialInstallFailed carries the classified error", () => {
+        const se = classifyInitialInstallError({ stdout: ERESOLVE_JSON, stderr: "", message: "x" }, {});
+        const marker = new InitialInstallFailed(se);
+        expect(marker).toBeInstanceOf(Error);
+        expect(marker.serverError).toBe(se);
+    });
+});
+//# sourceMappingURL=dependency-install-classifier.test.mjs.map

package/dist/cli-replacement/dependency-install-classifier.test.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-install-classifier.test.mjs","sourceRoot":"","sources":["../../src/cli-replacement/dependency-install-classifier.test.mts"],"names":[],"mappings":"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"}

package/dist/cli-replacement/dev-s3-restore.test.mjs

@@ -5,9 +5,11 @@ import * as path from "node:path";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import { packageJsonSnapshot } from "./package-json-snapshot.mjs";
 const execMock = vi.fn();
+const execFileMock = vi.fn();
 vi.mock("node:child_process", () => ({
-    default: { exec: execMock },
+    default: { exec: execMock, execFile: execFileMock },
     exec: execMock,
+    execFile: execFileMock,
 }));
 vi.mock("node:readline", () => ({
     default: {
@@ -46,6 +48,9 @@ const mockLogger = {
     error: vi.fn(),
     debug: vi.fn(),
 };
+const mockAiServiceState = vi.hoisted(() => ({
+    npmRegistryClient: undefined,
+}));
 vi.mock("../telemetry/logging.js", () => ({
     getLogger: () => mockLogger,
     getErrorMeta: vi.fn(() => ({})),
@@ -61,7 +66,12 @@ vi.mock("@opentelemetry/api", () => ({
 vi.mock("colorette", () => ({
     green: (s) => s,
 }));
-vi.mock("@superblocksteam/shared", () => ({
+vi.mock("@superblocksteam/shared", async (importOriginal) => ({
+    // dev.mts now transitively loads @superblocksteam/shared (via the npm-error
+    // classifier re-exported from vite-plugin-file-sync/npm-registry — APPS-4450),
+    // pulling in many named exports (DeploymentTypeEnum, ISocket, …). Spread the
+    // real module so the closed overrides below don't have to enumerate them.
+    ...(await importOriginal()),
     buildGithubSuperblocksSyncWorkflow: vi.fn(),
     buildGithubSuperblocksSyncWorkflowFromBaseUrl: vi.fn(),
     ConflictError: class ConflictError extends Error {
@@ -82,6 +92,12 @@ vi.mock("@superblocksteam/vite-plugin-file-sync/ai-service", () => ({
         initialize = vi.fn(async () => undefined);
         removeIntegrationCache = vi.fn(async () => undefined);
         chatSessionStore = { invalidateCache: vi.fn() };
+        // `dev.mts` reads this at startup for two paths: `syncHomeNpmrc`
+        // (APPS-4231 home `~/.npmrc` writer) and the startup `installPackages`
+        // call (APPS-4251 per-org `allow_install_scripts`). Returning undefined
+        // keeps the install path on the "no policy resolved" branch and is also
+        // valid input for the mocked-out `syncHomeNpmrc`.
+        getNpmRegistryClient = vi.fn(() => mockAiServiceState.npmRegistryClient);
     },
     AiServiceFeatureFlags: class {
         static create = vi.fn(() => ({}));
@@ -92,6 +108,20 @@ vi.mock("@superblocksteam/vite-plugin-file-sync/ai-service", () => ({
     isSdkApiTemplate: vi.fn(() => false),
     stripResolvedFromLockfile: vi.fn(async () => undefined),
 }));
+vi.mock("@superblocksteam/vite-plugin-file-sync/npm-registry", () => ({
+    shouldIgnoreInstallScripts: vi.fn(() => false),
+    // Used by the dependency-install-classifier reachable from installPackages'
+    // catch path (APPS-4450). Previously the only test that hit this codepath
+    // (`logs a structured error when the background install fails`) didn't
+    // assert classification, so the missing exports surfaced silently as a
+    // ReferenceError instead of an InitialInstallFailed. The new
+    // restart-vs-degrade test depends on installPackages re-throwing an actual
+    // InitialInstallFailed marker, so stub all classifier-required exports.
+    scrubSecrets: vi.fn((value) => value),
+    parseNpmJsonDiagnostic: vi.fn(() => ""),
+    parseNpmJsonError: vi.fn(() => null),
+    classifyNpmExecStderr: vi.fn(() => null),
+}));
 vi.mock("@superblocksteam/vite-plugin-file-sync/git-service", () => ({
     createGitService: vi.fn(async () => undefined),
 }));
@@ -154,6 +184,24 @@ const mockCheckVersions = vi.fn(async () => ({
 }));
 vi.mock("./automatic-upgrades.js", () => ({
     checkVersionsAndWritePackageJson: (...args) => mockCheckVersions(...args),
+    buildInstallEnv: (userconfigPath) => ({
+        ...process.env,
+        NPM_CONFIG_USERCONFIG: userconfigPath,
+        PNPM_CONFIG_USERCONFIG: userconfigPath,
+    }),
+}));
+// The home `~/.npmrc` writer (APPS-4231) is a best-effort step that runs
+// before auto-upgrade. Mock it out here so these tests stay focused on the
+// DBFS / S3 restore behaviour. The `AiService` mock above exposes a
+// minimal `getNpmRegistryClient()` stub so the call site doesn't `TypeError`
+// and silently swallow this mock.
+vi.mock("./home-npmrc.mjs", () => ({
+    syncHomeNpmrc: vi.fn(async () => ({
+        outcome: "skipped-not-configured",
+        path: "/tmp/.superblocks/npmrc",
+    })),
+    superblocksNpmrcPath: vi.fn(() => "/tmp/.superblocks/npmrc"),
+    superblocksLogsPath: vi.fn((appDir) => `${appDir}/.superblocks/logs`),
 }));
 vi.mock("./git-repo-setup.mjs", () => ({
     ensureRemoteHasDefaultBranch: vi.fn(async () => undefined),
@@ -207,6 +255,8 @@ function buildDevOptions(overrides = {}) {
         tokenManager: {
             getToken: vi.fn(() => "test-token"),
             onTokenRefresh: vi.fn(),
+            updateToken: vi.fn(),
+            getCurrentToken: vi.fn(() => "test-token"),
         },
         getCurrentToken: vi.fn(() => "test-token"),
         sdk: buildMockSdk(),
@@ -232,6 +282,7 @@ function expectInstallToHaveRun() {
 describe("dev startup after S3 workspace restore", () => {
     beforeEach(async () => {
         vi.clearAllMocks();
+        mockAiServiceState.npmRegistryClient = undefined;
         setupExecMock();
         mockCheckVersions.mockResolvedValue({
             cliUpdated: false,
@@ -454,6 +505,234 @@ describe("dev startup after S3 workspace restore", () => {
             await fs.rm(tmpDir, { recursive: true, force: true });
         }
     });
+    it("keeps forced npm install when unchanged restore inputs still need private registry validation", async () => {
+        mockAiServiceState.npmRegistryClient = {
+            getConfig: vi.fn(async () => ({
+                source: "configured",
+                config: { configured: true },
+            })),
+        };
+        const unchangedPackageJson = {
+            name: "test-app",
+            dependencies: { "@superblocksteam/library": "1.0.0" },
+        };
+        const { dev } = await import("./dev.mjs");
+        await dev(buildDevOptions({
+            forcePackageInstall: true,
+            packageJsonSnapshotBeforeRestore: packageJsonSnapshot(unchangedPackageJson),
+        }));
+        expectInstallToHaveRun();
+        expect(mockLogger.info).toHaveBeenCalledWith("Package install decision", expect.objectContaining({
+            forcePackageInstall: true,
+            forcePackageInstallRequested: true,
+            packageJsonRequiresInstall: false,
+        }));
+    });
+    it("runs npm install at startup when private registries are configured even without package changes", async () => {
+        mockAiServiceState.npmRegistryClient = {
+            getConfig: vi.fn(async () => ({
+                source: "configured",
+                config: { configured: true },
+            })),
+        };
+        const unchangedPackageJson = {
+            name: "test-app",
+            dependencies: { "@superblocksteam/library": "1.0.0" },
+        };
+        const { dev } = await import("./dev.mjs");
+        await dev(buildDevOptions({
+            forcePackageInstall: false,
+            packageJsonSnapshotBeforeRestore: packageJsonSnapshot(unchangedPackageJson),
+        }));
+        expectInstallToHaveRun();
+        expect(mockLogger.info).toHaveBeenCalledWith("Package install decision", expect.objectContaining({
+            forcePackageInstall: false,
+            forcePackageInstallRequested: false,
+            packageJsonRequiresInstall: false,
+            privateRegistryRequiresInstallValidation: true,
+        }));
+    });
+    it("does not upload package state when private registry validation install leaves the lockfile unchanged", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sdk-dev-private-registry-"));
+        const unchangedPackageJson = {
+            name: "test-app",
+            packageManager: "npm@10.0.0",
+            dependencies: { "@superblocksteam/library": "1.0.0" },
+        };
+        try {
+            await fs.mkdir(path.join(tmpDir, "node_modules"));
+            await fs.writeFile(path.join(tmpDir, "package.json"), JSON.stringify(unchangedPackageJson, null, 2));
+            await fs.writeFile(path.join(tmpDir, "package-lock.json"), JSON.stringify({ name: "test-app", lockfileVersion: 3 }, null, 2));
+            const { readPackage } = await import("read-pkg");
+            readPackage.mockImplementation(async ({ cwd }) => JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf-8")));
+            mockAiServiceState.npmRegistryClient = {
+                getConfig: vi.fn(async () => ({
+                    source: "configured",
+                    config: { configured: true },
+                })),
+            };
+            const { dev } = await import("./dev.mjs");
+            await dev(buildDevOptions({
+                cwd: tmpDir,
+                forcePackageInstall: false,
+                packageJsonSnapshotBeforeRestore: packageJsonSnapshot(unchangedPackageJson),
+            }));
+            expectInstallToHaveRun();
+            expect(mockSyncService.uploadDirectory).not.toHaveBeenCalled();
+            expect(mockSyncService.uploadDirectoryNowIfNeeded).not.toHaveBeenCalled();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("does NOT upload package state when the validation install only rewrites `resolved` URLs", async () => {
+        // The exact churn cycle flagged in review: `stripResolvedFromLockfile`
+        // removes every `resolved` URL before the install and npm writes them
+        // back, so a byte-level comparison would flag "changed" on EVERY
+        // registry-validation boot and re-upload the workspace to DBFS forever.
+        // `lockfileComparisonKey` ignores `resolved`, so a resolved-only rewrite
+        // must NOT trigger the upload.
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sdk-dev-private-registry-"));
+        const unchangedPackageJson = {
+            name: "test-app",
+            packageManager: "npm@10.0.0",
+            dependencies: { "@superblocksteam/library": "1.0.0" },
+        };
+        const strippedLockfile = {
+            name: "test-app",
+            lockfileVersion: 3,
+            packages: {
+                "node_modules/@superblocksteam/library": { version: "1.0.0" },
+            },
+        };
+        const rewrittenLockfile = {
+            name: "test-app",
+            lockfileVersion: 3,
+            packages: {
+                "node_modules/@superblocksteam/library": {
+                    version: "1.0.0",
+                    resolved: "https://registry.example.com/@superblocksteam/library/-/library-1.0.0.tgz",
+                },
+            },
+        };
+        try {
+            await fs.mkdir(path.join(tmpDir, "node_modules"));
+            await fs.writeFile(path.join(tmpDir, "package.json"), JSON.stringify(unchangedPackageJson, null, 2));
+            await fs.writeFile(path.join(tmpDir, "package-lock.json"), JSON.stringify(strippedLockfile, null, 2));
+            const { readPackage } = await import("read-pkg");
+            readPackage.mockImplementation(async ({ cwd }) => JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf-8")));
+            mockAiServiceState.npmRegistryClient = {
+                getConfig: vi.fn(async () => ({
+                    source: "configured",
+                    config: { configured: true },
+                })),
+            };
+            execMock.mockImplementation((_cmd, opts, cb) => {
+                const cwd = typeof opts === "object" ? opts.cwd : tmpDir;
+                void fs
+                    .writeFile(path.join(cwd ?? tmpDir, "package-lock.json"), JSON.stringify(rewrittenLockfile, null, 2))
+                    .then(() => {
+                    if (typeof opts === "function") {
+                        opts(null, { stdout: "installed" });
+                    }
+                    else {
+                        cb?.(null, { stdout: "installed" });
+                    }
+                });
+            });
+            const { dev } = await import("./dev.mjs");
+            await dev(buildDevOptions({
+                cwd: tmpDir,
+                forcePackageInstall: false,
+                packageJsonSnapshotBeforeRestore: packageJsonSnapshot(unchangedPackageJson),
+            }));
+            expectInstallToHaveRun();
+            expect(mockSyncService.uploadDirectory).not.toHaveBeenCalled();
+            expect(mockSyncService.uploadDirectoryNowIfNeeded).not.toHaveBeenCalled();
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("uploads package state when private registry validation install rewrites the lockfile", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sdk-dev-private-registry-"));
+        const unchangedPackageJson = {
+            name: "test-app",
+            packageManager: "npm@10.0.0",
+            dependencies: { "@superblocksteam/library": "1.0.0" },
+        };
+        try {
+            await fs.mkdir(path.join(tmpDir, "node_modules"));
+            await fs.writeFile(path.join(tmpDir, "package.json"), JSON.stringify(unchangedPackageJson, null, 2));
+            await fs.writeFile(path.join(tmpDir, "package-lock.json"), JSON.stringify({ name: "test-app", lockfileVersion: 3 }, null, 2));
+            const { readPackage } = await import("read-pkg");
+            readPackage.mockImplementation(async ({ cwd }) => JSON.parse(await fs.readFile(path.join(cwd, "package.json"), "utf-8")));
+            mockAiServiceState.npmRegistryClient = {
+                getConfig: vi.fn(async () => ({
+                    source: "configured",
+                    config: { configured: true },
+                })),
+            };
+            execMock.mockImplementation((_cmd, opts, cb) => {
+                const cwd = typeof opts === "object" ? opts.cwd : tmpDir;
+                void fs
+                    .writeFile(path.join(cwd ?? tmpDir, "package-lock.json"), JSON.stringify({ name: "test-app", lockfileVersion: 3, packages: {} }, null, 2))
+                    .then(() => {
+                    if (typeof opts === "function") {
+                        opts(null, { stdout: "installed" });
+                    }
+                    else {
+                        cb?.(null, { stdout: "installed" });
+                    }
+                });
+            });
+            const { dev } = await import("./dev.mjs");
+            await dev(buildDevOptions({
+                cwd: tmpDir,
+                forcePackageInstall: false,
+                packageJsonSnapshotBeforeRestore: packageJsonSnapshot(unchangedPackageJson),
+            }));
+            expectInstallToHaveRun();
+            expect(mockSyncService.uploadDirectory).toHaveBeenCalledWith("cli:sdk");
+            expect(mockSyncService.uploadDirectoryNowIfNeeded).toHaveBeenCalledWith("cli:sdk");
+        }
+        finally {
+            await fs.rm(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it("does NOT force the startup install when the registry config is unreachable (fail closed, APPS-4527)", async () => {
+        // `unreachable` with no last-known-good means we could not materialize
+        // the right `.npmrc`. Forcing an install would re-resolve a
+        // private-registry org's lockfile against whatever registry happens to
+        // be on disk — validating against the wrong host and writing its URLs
+        // back into the lockfile. Fail closed instead (APPS-4370 principle):
+        // keep today's snapshot decision and skip the install.
+        mockAiServiceState.npmRegistryClient = {
+            getConfig: vi.fn(async () => ({ source: "unreachable" })),
+        };
+        const { dev } = await import("./dev.mjs");
+        await dev(buildDevOptions());
+        expect(execMock).not.toHaveBeenCalled();
+        expect(mockLogger.info).toHaveBeenCalledWith("Package install decision", expect.objectContaining({
+            packageJsonRequiresInstall: false,
+            forcePackageInstall: false,
+            privateRegistryRequiresInstallValidation: false,
+        }));
+    });
+    it("does NOT force the startup install when registry config resolution throws (fail closed, APPS-4527)", async () => {
+        mockAiServiceState.npmRegistryClient = {
+            getConfig: vi.fn(async () => {
+                throw new Error("registry config fetch failed");
+            }),
+        };
+        const { dev } = await import("./dev.mjs");
+        await dev(buildDevOptions());
+        expect(execMock).not.toHaveBeenCalled();
+        expect(mockLogger.warn).toHaveBeenCalledWith("Could not resolve npm registry config for startup install validation; preserving package snapshot decision", expect.anything());
+        expect(mockLogger.info).toHaveBeenCalledWith("Package install decision", expect.objectContaining({
+            privateRegistryRequiresInstallValidation: false,
+        }));
+    });
 });
 // Wires up `execMock` so install calls hang until the test calls
 // `finishInstall`. We stash the promisify callback directly rather than
@@ -503,6 +782,7 @@ function setupDeferredInstallMock(options = {}) {
 describe("dev background package install join semantics", () => {
     beforeEach(async () => {
         vi.clearAllMocks();
+        mockAiServiceState.npmRegistryClient = undefined;
         mockCheckVersions.mockResolvedValue({
             cliUpdated: false,
             upgradePromises: [],
@@ -543,31 +823,140 @@ describe("dev background package install join semantics", () => {
     it("logs a structured error when the background install fails", async () => {
         const deferred = setupDeferredInstallMock({ fail: true });
         // Use upgradePromises so the install runs without forcing the upload
-        // path — the failure then propagates through the pre-Vite join, whose
-        // outer catch only sets the span status and rethrows (no process.exit,
-        // which vitest replaces with a throw that becomes an unhandled error).
+        // path — the failure propagates through the pre-Vite join. With the
+        // dependency-install-classifier fully wired in tests, the rejection is
+        // an InitialInstallFailed marker and `handleStartupError` routes it to
+        // "degrade" (Vite still starts up, dev() resolves with the error
+        // recorded on devServerStatus). The point of THIS test is the
+        // independent `.catch` backstop on packageInstallPromise — it must
+        // log a structured error regardless of which downstream join consumes
+        // the rejection.
         mockCheckVersions.mockResolvedValue({
             cliUpdated: false,
             upgradePromises: [Promise.resolve()],
         });
         const { dev } = await import("./dev.mjs");
-        // Pre-attach a catcher so vitest's unhandled-rejection detector observes
-        // the rejection synchronously with promise creation; without this, the
-        // .catch backstop's logging counts as a handler but lands on the
-        // microtask queue after vitest's check.
-        let caughtError;
-        const devPromise = dev(buildDevOptions()).catch((err) => {
-            caughtError = err;
-        });
+        const devPromise = dev(buildDevOptions()).catch(() => undefined);
         await deferred.awaitInstallStarted();
         await deferred.finishInstall();
         await devPromise;
-        expect(caughtError).toBeDefined();
         // The .catch backstop fires regardless and tags the log with errorId so
         // alert rules can match without needing typed attributes.
         expect(mockLogger.error.mock.calls.some((call) => typeof call[0] === "string" &&
             call[0].includes("Background package install failed") &&
             call[0].includes("errorId=DEV_SERVER_BG_INSTALL_FAILED"))).toBe(true);
     });
+    // APPS-4450 review: an InitialInstallFailed observed in the "before upload"
+    // join must NOT preempt a successful CLI upgrade restart. Previously the
+    // join's rejection was caught by the outer sync/setup catch (→ degrade) and
+    // execution never reached the `hasCliUpdated` branch, so the restart was
+    // silently dropped. The fix catches the join locally when `hasCliUpdated`
+    // and falls through to the restart block.
+    it("prioritises CLI restart over install-failure degrade when both fire in the upload path", async () => {
+        const deferred = setupDeferredInstallMock({ fail: true });
+        // CLI upgrade succeeds + `forcePackageInstall` triggers the upload path.
+        mockCheckVersions.mockResolvedValue({
+            cliUpdated: true,
+            upgradePromises: [Promise.resolve()],
+        });
+        // Capture `process.exit` synchronously; the production path calls it on
+        // the restart with AUTO_UPGRADE_EXIT_CODE (mocked to 99). Track every
+        // call and throw a tagged error so the test can assert the exit code
+        // without actually terminating the vitest worker. We replace
+        // `process.exit` directly instead of `vi.spyOn` — vitest's `process`
+        // object is partially shadowed and `vi.spyOn(process, "exit")` swallows
+        // calls intermittently here.
+        const originalExit = process.exit;
+        const exitCalls = [];
+        process.exit = (code) => {
+            exitCalls.push(code);
+            throw new Error(`__test_process_exit__:${String(code)}`);
+        };
+        try {
+            const { dev } = await import("./dev.mjs");
+            let caughtError;
+            const devPromise = dev(buildDevOptions({ forcePackageInstall: true })).catch((err) => {
+                caughtError = err;
+            });
+            await deferred.awaitInstallStarted();
+            await deferred.finishInstall();
+            await devPromise;
+            // First exit call MUST be the CLI-restart with AUTO_UPGRADE_EXIT_CODE
+            // (mocked to 99). The throw escapes through the outer catch, which
+            // routes the non-InitialInstallFailed thrown wrapper through
+            // handleStartupError → exit, so a follow-up `process.exit(1)` is
+            // expected and benign. The invariant is the FIRST call.
+            expect(exitCalls[0]).toBe(99);
+            // devPromise resolved (or rejected) after the chain settled.
+            expect(caughtError).toBeDefined();
+            // Upload was skipped — install failed before the upload body could run
+            // and the local catch routed straight to the restart branch.
+            expect(mockSyncService.uploadDirectory).not.toHaveBeenCalled();
+            expect(mockSyncService.uploadDirectoryNowIfNeeded).not.toHaveBeenCalled();
+            // Restart actually got reached (logged + skip-upload reason logged).
+            expect(mockLogger.info).toHaveBeenCalledWith("CLI was updated, restarting the dev server…");
+            expect(mockLogger.info.mock.calls.some((call) => typeof call[0] === "string" &&
+                call[0].includes("Initial package install failed before startup upload"))).toBe(true);
+        }
+        finally {
+            process.exit = originalExit;
+        }
+    });
+    // APPS-4450 review (companion to above): the new local try/catch in the
+    // upload path must only swallow `InitialInstallFailed`. A non-marker
+    // rejection from `joinUpgradeThenInstall("before upload")` (e.g. a failed
+    // package upgrade) must rethrow so the outer sync/setup catch routes it to
+    // `process.exit(1)` — even when `hasCliUpdated` is true. Otherwise an
+    // upgrade rejection could be silently dropped on the upload path.
+    it("rethrows non-InitialInstallFailed join errors so the outer catch exits", async () => {
+        // Install succeeds instantly — only the UPGRADE rejects, so the join's
+        // first await (`joinPackageUpgrade`) is what surfaces.
+        execMock.mockImplementation((_cmd, opts, cb) => {
+            const callback = typeof opts === "function"
+                ? opts
+                : cb;
+            callback?.(null, { stdout: "installed" });
+        });
+        // hasCliUpdated=true ensures we'd hit the restart branch IF the local
+        // catch wrongly swallowed the rejection. A rejecting upgrade promise
+        // surfaces a generic Error (not InitialInstallFailed), so the local catch
+        // must rethrow.
+        mockCheckVersions.mockResolvedValue({
+            cliUpdated: true,
+            upgradePromises: [Promise.reject(new Error("simulated upgrade failure"))],
+        });
+        const originalExit = process.exit;
+        const exitCalls = [];
+        process.exit = (code) => {
+            exitCalls.push(code);
+            throw new Error(`__test_process_exit__:${String(code)}`);
+        };
+        try {
+            const { dev } = await import("./dev.mjs");
+            let caughtError;
+            await dev(buildDevOptions({ forcePackageInstall: true })).catch((err) => {
+                caughtError = err;
+            });
+            // First exit MUST be the outer-catch exit(1), NOT the
+            // AUTO_UPGRADE_EXIT_CODE (99). If the local catch wrongly swallowed
+            // the upgrade rejection, execution would fall through to the
+            // `if (hasCliUpdated)` restart branch and call exit(99).
+            expect(exitCalls[0]).toBe(1);
+            expect(exitCalls[0]).not.toBe(99);
+            expect(caughtError).toBeDefined();
+            // Upload skipped — join rejected before the upload body could run.
+            expect(mockSyncService.uploadDirectory).not.toHaveBeenCalled();
+            expect(mockSyncService.uploadDirectoryNowIfNeeded).not.toHaveBeenCalled();
+            // Restart was NOT reached — outer catch exited before that block.
+            expect(mockLogger.info).not.toHaveBeenCalledWith("CLI was updated, restarting the dev server…");
+            // The skip-upload-for-restart log must NOT fire either; it's gated on
+            // the `InitialInstallFailed` branch of the local catch.
+            expect(mockLogger.info.mock.calls.some((call) => typeof call[0] === "string" &&
+                call[0].includes("Initial package install failed before startup upload"))).toBe(false);
+        }
+        finally {
+            process.exit = originalExit;
+        }
+    });
 });
 //# sourceMappingURL=dev-s3-restore.test.mjs.map