@peers-app/peers-sdk 0.18.8 → 0.19.6

package/dist/package-installer/package-installer.test.js

@@ -0,0 +1,666 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const file_types_1 = require("../data/files/file.types");
+const utils_1 = require("../utils");
+const package_installer_1 = require("./package-installer");
+// --- Mocks for SDK internals ---
+const mockFindOnePV = jest.fn();
+const mockSignAndSavePV = jest.fn();
+jest.mock("../data/package-versions", () => {
+    const actual = jest.requireActual("../data/package-versions");
+    return {
+        ...actual,
+        PackageVersions: () => ({
+            findOne: mockFindOnePV,
+            signAndSave: mockSignAndSavePV,
+            list: jest.fn().mockResolvedValue([]),
+        }),
+    };
+});
+const mockGetPkg = jest.fn();
+const mockSignAndSavePkg = jest.fn();
+const mockListPkgs = jest.fn();
+jest.mock("../data/packages", () => ({
+    Packages: () => ({
+        get: mockGetPkg,
+        signAndSave: mockSignAndSavePkg,
+        list: mockListPkgs,
+    }),
+}));
+const mockFindOneFile = jest.fn();
+const mockSaveFile = jest.fn();
+jest.mock("../data/files/files", () => ({
+    Files: () => ({
+        findOne: mockFindOneFile,
+        saveFile: mockSaveFile,
+    }),
+}));
+const mockUpdatePackagePrefs = jest.fn();
+const mockResolveDevicePackageVersion = jest.fn();
+jest.mock("../data/package-version-resolver", () => ({
+    updatePackagePrefs: (...args) => mockUpdatePackagePrefs(...args),
+    resolveDevicePackageVersion: (...args) => mockResolveDevicePackageVersion(...args),
+}));
+const mockGroupDeviceVar = jest.fn();
+jest.mock("../data/persistent-vars", () => {
+    const actual = jest.requireActual("../data/persistent-vars");
+    return {
+        ...actual,
+        groupDeviceVar: (...args) => mockGroupDeviceVar(...args),
+    };
+});
+// --- Test utilities ---
+function makeMockDeps(files, shellExec) {
+    return {
+        fs: {
+            readFile: jest.fn(async (path) => {
+                if (files[path] !== undefined)
+                    return files[path];
+                throw new Error(`ENOENT: ${path}`);
+            }),
+            writeFile: jest.fn(async () => { }),
+            exists: jest.fn(async (path) => {
+                if (path in files)
+                    return true;
+                // Treat as directory if any file has this path as a prefix
+                const dirPrefix = path.endsWith("/") ? path : `${path}/`;
+                return Object.keys(files).some((f) => f.startsWith(dirPrefix));
+            }),
+            readJson: jest.fn(async (path) => {
+                if (files[path] === undefined)
+                    throw new Error(`ENOENT: ${path}`);
+                return JSON.parse(files[path]);
+            }),
+        },
+        shell: {
+            exec: shellExec ?? jest.fn(async () => ({ stdout: "", stderr: "" })),
+        },
+        resolvePath: (...segments) => segments.join("/"),
+        packagesRootDir: "/packages",
+    };
+}
+function mockDataContext(overrides = {}) {
+    return {
+        packageLoader: {
+            loadPackage: jest.fn().mockResolvedValue(undefined),
+        },
+        ...overrides,
+    };
+}
+// --- Tests ---
+beforeEach(() => {
+    jest.clearAllMocks();
+    mockSignAndSavePV.mockImplementation(async (pv) => pv);
+    mockSaveFile.mockImplementation(async (metadata, _content) => ({
+        fileId: metadata.fileId,
+        fileHash: (0, file_types_1.computeFileHash)(typeof _content === "string" ? _content : ""),
+        name: metadata.name,
+        fileSize: metadata.fileSize,
+        mimeType: metadata.mimeType,
+    }));
+});
+describe("saveBundleFile", () => {
+    it("creates a new File record when none exists with the same hash", async () => {
+        mockFindOneFile.mockResolvedValue(undefined);
+        const dc = mockDataContext();
+        const content = "console.log('hello');";
+        const result = await (0, package_installer_1.saveBundleFile)(dc, content, "pkg-package.bundle.js", "pkgId");
+        expect(mockFindOneFile).toHaveBeenCalledWith({
+            name: "pkg-package.bundle.js",
+            fileHash: (0, file_types_1.computeFileHash)(content),
+        });
+        expect(mockSaveFile).toHaveBeenCalledTimes(1);
+        expect(result.fileHash).toBe((0, file_types_1.computeFileHash)(content));
+        expect(result.fileId).toBeDefined();
+    });
+    it("returns existing File when hash matches (deduplication)", async () => {
+        const existingFileId = (0, utils_1.newid)();
+        const content = "console.log('same');";
+        const expectedHash = (0, file_types_1.computeFileHash)(content);
+        mockFindOneFile.mockResolvedValue({
+            fileId: existingFileId,
+            fileHash: expectedHash,
+        });
+        const dc = mockDataContext();
+        const result = await (0, package_installer_1.saveBundleFile)(dc, content, "pkg-package.bundle.js", "pkgId");
+        expect(result.fileId).toBe(existingFileId);
+        expect(result.fileHash).toBe(expectedHash);
+        expect(mockSaveFile).not.toHaveBeenCalled();
+    });
+    it("creates different file records for different content", async () => {
+        mockFindOneFile.mockResolvedValue(undefined);
+        const dc = mockDataContext();
+        const result1 = await (0, package_installer_1.saveBundleFile)(dc, "content-a", "pkg-bundle.js", "pkgId");
+        const result2 = await (0, package_installer_1.saveBundleFile)(dc, "content-b", "pkg-bundle.js", "pkgId");
+        expect(result1.fileHash).not.toBe(result2.fileHash);
+        expect(mockSaveFile).toHaveBeenCalledTimes(2);
+    });
+});
+describe("getPackageInfo", () => {
+    it("reads name, version, description, packageId from package.json", async () => {
+        const deps = makeMockDeps({
+            "/pkg/package.json": JSON.stringify({
+                name: "my-package",
+                version: "2.1.0",
+                description: "A test package",
+                peers: { packageId: "abc123" },
+            }),
+        });
+        const info = await (0, package_installer_1.getPackageInfo)(deps, "/pkg");
+        expect(info.name).toBe("my-package");
+        expect(info.version).toBe("2.1.0");
+        expect(info.description).toBe("A test package");
+        expect(info.packageId).toBe("abc123");
+    });
+    it("enriches description from README first paragraph", async () => {
+        const deps = makeMockDeps({
+            "/pkg/package.json": JSON.stringify({
+                name: "my-package",
+                description: "short desc",
+            }),
+            "/pkg/README.md": "# My Package\n\nThis is a richer description from the README.\n\n## Details",
+        });
+        const info = await (0, package_installer_1.getPackageInfo)(deps, "/pkg");
+        expect(info.description).toBe("This is a richer description from the README.");
+    });
+    it("detects remoteRepo from git remote", async () => {
+        const shellExec = jest.fn(async () => ({
+            stdout: "https://github.com/org/repo.git\n",
+            stderr: "",
+        }));
+        const deps = makeMockDeps({
+            "/pkg/package.json": JSON.stringify({ name: "my-package" }),
+        }, shellExec);
+        const info = await (0, package_installer_1.getPackageInfo)(deps, "/pkg");
+        expect(shellExec).toHaveBeenCalledWith("git remote get-url origin", { cwd: "/pkg" });
+        expect(info.remoteRepo).toBe("https://github.com/org/repo.git");
+    });
+    it("handles missing git remote gracefully", async () => {
+        const shellExec = jest.fn(async () => {
+            throw new Error("fatal: No remote configured");
+        });
+        const deps = makeMockDeps({ "/pkg/package.json": JSON.stringify({ name: "test" }) }, shellExec);
+        const info = await (0, package_installer_1.getPackageInfo)(deps, "/pkg");
+        expect(info.remoteRepo).toBeUndefined();
+        expect(info.name).toBe("test");
+    });
+    it("handles missing README gracefully", async () => {
+        const deps = makeMockDeps({
+            "/pkg/package.json": JSON.stringify({
+                name: "pkg",
+                description: "from json",
+            }),
+        });
+        const info = await (0, package_installer_1.getPackageInfo)(deps, "/pkg");
+        expect(info.description).toBe("from json");
+    });
+    it("uses 'unknown' when package.json has no name", async () => {
+        const deps = makeMockDeps({
+            "/pkg/package.json": JSON.stringify({}),
+        });
+        const info = await (0, package_installer_1.getPackageInfo)(deps, "/pkg");
+        expect(info.name).toBe("unknown");
+    });
+});
+describe("extractReadmeDescription", () => {
+    // The function is not exported, but we re-exported it for testing.
+    // Actually let's test it indirectly via getPackageInfo, but we also
+    // re-export it. For now, test through getPackageInfo behavior.
+    it("skips headings and returns first paragraph", async () => {
+        const deps = makeMockDeps({
+            "/pkg/package.json": JSON.stringify({ name: "x" }),
+            "/pkg/README.md": "# Title\n\n## Subtitle\n\nActual description here.\nSecond line.\n\n## Another section",
+        });
+        const info = await (0, package_installer_1.getPackageInfo)(deps, "/pkg");
+        expect(info.description).toBe("Actual description here. Second line.");
+    });
+    it("returns undefined for README with only headings", async () => {
+        const deps = makeMockDeps({
+            "/pkg/package.json": JSON.stringify({ name: "x", description: "fallback" }),
+            "/pkg/README.md": "# Title\n\n## Section 1\n\n## Section 2\n",
+        });
+        const info = await (0, package_installer_1.getPackageInfo)(deps, "/pkg");
+        // Should fall back to package.json description since README has no paragraphs
+        expect(info.description).toBe("fallback");
+    });
+});
+describe("installPackageFromBundles", () => {
+    const packageId = "testpkg1234567890abcde";
+    const packageBundle = "module.exports = { init() {} };";
+    const routesBundle = "module.exports = { routes: [] };";
+    const uiBundle = "module.exports = { components: [] };";
+    function setupBasicInstall() {
+        const files = {
+            [`/packages/${packageId}/package.json`]: JSON.stringify({
+                name: "test-pkg",
+                version: "1.2.3",
+                description: "Test package",
+            }),
+            [`/packages/${packageId}/dist/package.bundle.js`]: packageBundle,
+            [`/packages/${packageId}/dist/routes.bundle.js`]: routesBundle,
+            [`/packages/${packageId}/dist/uis.bundle.js`]: uiBundle,
+        };
+        const deps = makeMockDeps(files);
+        // Mock groupDeviceVar to return the local path
+        mockGroupDeviceVar.mockReturnValue(Object.assign(() => `/packages/${packageId}`, {
+            loadingPromise: Promise.resolve(),
+        }));
+        // No existing PV
+        mockFindOnePV.mockResolvedValue(undefined);
+        mockFindOneFile.mockResolvedValue(undefined);
+        // Package exists
+        mockGetPkg.mockResolvedValue({
+            packageId,
+            name: "test-pkg",
+            description: "Old description",
+            signature: "",
+            createdBy: "user1",
+        });
+        return { deps, files };
+    }
+    it("installs a new package version from bundles", async () => {
+        const { deps } = setupBasicInstall();
+        const dc = mockDataContext();
+        const result = await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(result.unchanged).toBe(false);
+        expect(result.packageVersion.packageId).toBe(packageId);
+        expect(result.packageVersion.version).toBe("1.2.3");
+        expect(result.packageVersion.versionTag).toBe("dev");
+        expect(result.packageVersion.packageBundleFileId).toBeDefined();
+        expect(result.packageVersion.routesBundleFileId).toBeDefined();
+        expect(result.packageVersion.uiBundleFileId).toBeDefined();
+        expect(mockSignAndSavePV).toHaveBeenCalledTimes(1);
+    });
+    it("returns unchanged when PV hash matches", async () => {
+        const { deps } = setupBasicInstall();
+        const dc = mockDataContext();
+        const packageHash = (0, file_types_1.computeFileHash)(packageBundle);
+        const routesHash = (0, file_types_1.computeFileHash)(routesBundle);
+        const uiHash = (0, file_types_1.computeFileHash)(uiBundle);
+        // Import the actual function to compute expected hash
+        const { computePackageVersionHash } = jest.requireActual("../data/package-versions");
+        const expectedPvHash = computePackageVersionHash("1.2.3", "", packageHash, routesHash, uiHash);
+        const existingPv = {
+            packageVersionId: (0, utils_1.newid)(),
+            packageId,
+            version: "1.2.3",
+            versionTag: "dev",
+            packageVersionHash: expectedPvHash,
+            packageBundleFileId: (0, utils_1.newid)(),
+            packageBundleFileHash: packageHash,
+            signature: "",
+            createdBy: "user1",
+            createdAt: new Date().toISOString(),
+        };
+        mockFindOnePV.mockResolvedValue(existingPv);
+        const result = await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(result.unchanged).toBe(true);
+        expect(result.packageVersion).toBe(existingPv);
+        expect(mockSaveFile).not.toHaveBeenCalled();
+        expect(mockSignAndSavePV).not.toHaveBeenCalled();
+    });
+    it("reuses existing PV id when updating", async () => {
+        const { deps } = setupBasicInstall();
+        const dc = mockDataContext();
+        const existingPvId = (0, utils_1.newid)();
+        mockFindOnePV.mockResolvedValue({
+            packageVersionId: existingPvId,
+            packageId,
+            version: "1.0.0",
+            versionTag: "dev",
+            packageVersionHash: "old-hash-different",
+            packageBundleFileId: (0, utils_1.newid)(),
+            packageBundleFileHash: "old-bundle-hash",
+            signature: "old-sig",
+            createdBy: "original-creator",
+            createdAt: "2024-01-01T00:00:00Z",
+        });
+        const result = await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(result.unchanged).toBe(false);
+        expect(result.packageVersion.packageVersionId).toBe(existingPvId);
+        expect(result.packageVersion.version).toBe("1.2.3");
+        expect(result.packageVersion.createdBy).toBe("original-creator");
+    });
+    it("throws when package directory does not exist", async () => {
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        mockGroupDeviceVar.mockReturnValue(Object.assign(() => "/nonexistent", {
+            loadingPromise: Promise.resolve(),
+        }));
+        await expect((0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, { skipLoad: true, skipResolve: true })).rejects.toThrow("Package directory does not exist");
+    });
+    it("throws when package.bundle.js is missing", async () => {
+        const deps = makeMockDeps({
+            [`/packages/${packageId}/package.json`]: JSON.stringify({ name: "x", version: "1.0.0" }),
+        });
+        const dc = mockDataContext();
+        mockGroupDeviceVar.mockReturnValue(Object.assign(() => `/packages/${packageId}`, {
+            loadingPromise: Promise.resolve(),
+        }));
+        await expect((0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, { skipLoad: true, skipResolve: true })).rejects.toThrow("Required bundle not found");
+    });
+    it("handles package with only package.bundle.js (no routes or UI)", async () => {
+        const files = {
+            [`/packages/${packageId}/package.json`]: JSON.stringify({
+                name: "minimal-pkg",
+                version: "0.1.0",
+            }),
+            [`/packages/${packageId}/dist/package.bundle.js`]: packageBundle,
+        };
+        const deps = makeMockDeps(files);
+        const dc = mockDataContext();
+        mockGroupDeviceVar.mockReturnValue(Object.assign(() => `/packages/${packageId}`, {
+            loadingPromise: Promise.resolve(),
+        }));
+        mockFindOnePV.mockResolvedValue(undefined);
+        mockFindOneFile.mockResolvedValue(undefined);
+        mockGetPkg.mockResolvedValue({
+            packageId,
+            name: "minimal-pkg",
+            description: "",
+            signature: "",
+            createdBy: "u",
+        });
+        const result = await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(result.unchanged).toBe(false);
+        expect(result.packageVersion.routesBundleFileId).toBeUndefined();
+        expect(result.packageVersion.uiBundleFileId).toBeUndefined();
+        expect(mockSaveFile).toHaveBeenCalledTimes(1);
+    });
+    it("uses opts.localPath when provided instead of device var", async () => {
+        const customPath = "/custom/path/to/pkg";
+        const files = {
+            [`${customPath}/package.json`]: JSON.stringify({ name: "custom", version: "3.0.0" }),
+            [`${customPath}/dist/package.bundle.js`]: packageBundle,
+        };
+        const deps = makeMockDeps(files);
+        const dc = mockDataContext();
+        mockFindOnePV.mockResolvedValue(undefined);
+        mockFindOneFile.mockResolvedValue(undefined);
+        mockGetPkg.mockResolvedValue({
+            packageId,
+            name: "custom",
+            description: "",
+            signature: "",
+            createdBy: "u",
+        });
+        const result = await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            localPath: customPath,
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(result.packageVersion.version).toBe("3.0.0");
+        expect(mockGroupDeviceVar).not.toHaveBeenCalled();
+    });
+    it("uses opts.versionTag when provided", async () => {
+        const { deps } = setupBasicInstall();
+        const dc = mockDataContext();
+        const result = await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            versionTag: "beta",
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(result.packageVersion.versionTag).toBe("beta");
+        expect(mockFindOnePV).toHaveBeenCalledWith({ packageId, versionTag: "beta" });
+    });
+    it("loads the package when skipLoad is false", async () => {
+        const { deps } = setupBasicInstall();
+        const mockLoadPackage = jest.fn().mockResolvedValue({ packageId, appNavs: [] });
+        const dc = mockDataContext({
+            packageLoader: { loadPackage: mockLoadPackage },
+        });
+        const result = await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            skipResolve: true,
+        });
+        expect(mockLoadPackage).toHaveBeenCalledWith(expect.objectContaining({ packageId }), expect.objectContaining({ force: true }));
+        expect(result.loaded).toEqual({ packageId, appNavs: [] });
+    });
+    it("updates appNavs on PV when loaded package provides them", async () => {
+        const { deps } = setupBasicInstall();
+        const appNavs = [{ label: "Test", route: "/test" }];
+        const mockLoadPackage = jest.fn().mockResolvedValue({ packageId, appNavs });
+        const dc = mockDataContext({
+            packageLoader: { loadPackage: mockLoadPackage },
+        });
+        await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, { skipResolve: true });
+        // signAndSave should be called twice: once for initial PV, once for appNavs update
+        expect(mockSignAndSavePV).toHaveBeenCalledTimes(2);
+        const secondCall = mockSignAndSavePV.mock.calls[1][0];
+        expect(secondCall.appNavs).toEqual(appNavs);
+    });
+    it("calls updatePackagePrefs and resolveDevicePackageVersion when skipResolve is false", async () => {
+        const { deps } = setupBasicInstall();
+        const dc = mockDataContext();
+        await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId);
+        expect(mockUpdatePackagePrefs).toHaveBeenCalledWith(packageId, expect.objectContaining({ activePackageVersionId: expect.any(String) }), dc);
+        expect(mockResolveDevicePackageVersion).toHaveBeenCalledWith(expect.objectContaining({ packageId }), dc, expect.objectContaining({ force: true }));
+    });
+    it("updates package description when info differs", async () => {
+        const { deps } = setupBasicInstall();
+        const dc = mockDataContext();
+        await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({ description: "Test package" }));
+    });
+    it("does not update package description when unchanged", async () => {
+        const files = {
+            [`/packages/${packageId}/package.json`]: JSON.stringify({
+                name: "test-pkg",
+                version: "1.0.0",
+                description: "Same description",
+            }),
+            [`/packages/${packageId}/dist/package.bundle.js`]: packageBundle,
+        };
+        const deps = makeMockDeps(files);
+        const dc = mockDataContext();
+        mockGroupDeviceVar.mockReturnValue(Object.assign(() => `/packages/${packageId}`, {
+            loadingPromise: Promise.resolve(),
+        }));
+        mockFindOnePV.mockResolvedValue(undefined);
+        mockFindOneFile.mockResolvedValue(undefined);
+        mockGetPkg.mockResolvedValue({
+            packageId,
+            name: "test-pkg",
+            description: "Same description",
+            signature: "",
+            createdBy: "u",
+        });
+        await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(mockSignAndSavePkg).not.toHaveBeenCalled();
+    });
+    it("defaults version to 0.0.1 when package.json has no version", async () => {
+        const files = {
+            [`/packages/${packageId}/package.json`]: JSON.stringify({ name: "no-version" }),
+            [`/packages/${packageId}/dist/package.bundle.js`]: packageBundle,
+        };
+        const deps = makeMockDeps(files);
+        const dc = mockDataContext();
+        mockGroupDeviceVar.mockReturnValue(Object.assign(() => `/packages/${packageId}`, {
+            loadingPromise: Promise.resolve(),
+        }));
+        mockFindOnePV.mockResolvedValue(undefined);
+        mockFindOneFile.mockResolvedValue(undefined);
+        mockGetPkg.mockResolvedValue({
+            packageId,
+            name: "no-version",
+            description: "",
+            signature: "",
+            createdBy: "u",
+        });
+        const result = await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(result.packageVersion.version).toBe("0.0.1");
+    });
+});
+describe("installAllPackageBundles", () => {
+    it("installs bundles for all non-disabled packages", async () => {
+        const pkg1Id = (0, utils_1.newid)();
+        const pkg2Id = (0, utils_1.newid)();
+        mockListPkgs.mockResolvedValue([
+            { packageId: pkg1Id, name: "pkg1", disabled: false },
+            { packageId: pkg2Id, name: "pkg2", disabled: false },
+        ]);
+        const packageBundle = "exports = {};";
+        const files = {
+            [`/packages/${pkg1Id}/package.json`]: JSON.stringify({ name: "pkg1", version: "1.0.0" }),
+            [`/packages/${pkg1Id}/dist/package.bundle.js`]: packageBundle,
+            [`/packages/${pkg2Id}/package.json`]: JSON.stringify({ name: "pkg2", version: "1.0.0" }),
+            [`/packages/${pkg2Id}/dist/package.bundle.js`]: packageBundle,
+        };
+        const deps = makeMockDeps(files);
+        const dc = mockDataContext();
+        mockGroupDeviceVar.mockImplementation((name) => {
+            const id = name.replace("packageLocalPath_", "");
+            return Object.assign(() => `/packages/${id}`, {
+                loadingPromise: Promise.resolve(),
+            });
+        });
+        mockFindOnePV.mockResolvedValue(undefined);
+        mockFindOneFile.mockResolvedValue(undefined);
+        mockGetPkg.mockImplementation(async (id) => ({
+            packageId: id,
+            name: id === pkg1Id ? "pkg1" : "pkg2",
+            description: "",
+            signature: "",
+            createdBy: "u",
+        }));
+        await (0, package_installer_1.installAllPackageBundles)(dc, deps);
+        // signAndSave called for each package's PV
+        expect(mockSignAndSavePV).toHaveBeenCalledTimes(2);
+    });
+    it("skips disabled packages", async () => {
+        const enabledId = (0, utils_1.newid)();
+        const disabledId = (0, utils_1.newid)();
+        mockListPkgs.mockResolvedValue([
+            { packageId: enabledId, name: "enabled", disabled: false },
+            { packageId: disabledId, name: "disabled", disabled: true },
+        ]);
+        const files = {
+            [`/packages/${enabledId}/package.json`]: JSON.stringify({
+                name: "enabled",
+                version: "1.0.0",
+            }),
+            [`/packages/${enabledId}/dist/package.bundle.js`]: "code",
+        };
+        const deps = makeMockDeps(files);
+        const dc = mockDataContext();
+        mockGroupDeviceVar.mockImplementation((name) => {
+            const id = name.replace("packageLocalPath_", "");
+            return Object.assign(() => `/packages/${id}`, {
+                loadingPromise: Promise.resolve(),
+            });
+        });
+        mockFindOnePV.mockResolvedValue(undefined);
+        mockFindOneFile.mockResolvedValue(undefined);
+        mockGetPkg.mockImplementation(async (id) => ({
+            packageId: id,
+            name: "enabled",
+            description: "",
+            signature: "",
+            createdBy: "u",
+        }));
+        await (0, package_installer_1.installAllPackageBundles)(dc, deps);
+        expect(mockSignAndSavePV).toHaveBeenCalledTimes(1);
+    });
+    it("continues installing other packages when one fails", async () => {
+        const pkg1Id = (0, utils_1.newid)();
+        const pkg2Id = (0, utils_1.newid)();
+        mockListPkgs.mockResolvedValue([
+            { packageId: pkg1Id, name: "failing-pkg" },
+            { packageId: pkg2Id, name: "good-pkg" },
+        ]);
+        // pkg1 has no dist dir (will fail), pkg2 is fine
+        const files = {
+            [`/packages/${pkg1Id}/package.json`]: JSON.stringify({ name: "failing", version: "1.0.0" }),
+            [`/packages/${pkg2Id}/package.json`]: JSON.stringify({ name: "good", version: "1.0.0" }),
+            [`/packages/${pkg2Id}/dist/package.bundle.js`]: "code",
+        };
+        const deps = makeMockDeps(files);
+        const dc = mockDataContext();
+        mockGroupDeviceVar.mockImplementation((name) => {
+            const id = name.replace("packageLocalPath_", "");
+            return Object.assign(() => `/packages/${id}`, {
+                loadingPromise: Promise.resolve(),
+            });
+        });
+        mockFindOnePV.mockResolvedValue(undefined);
+        mockFindOneFile.mockResolvedValue(undefined);
+        mockGetPkg.mockImplementation(async (id) => ({
+            packageId: id,
+            name: id === pkg1Id ? "failing" : "good",
+            description: "",
+            signature: "",
+            createdBy: "u",
+        }));
+        const consoleSpy = jest.spyOn(console, "error").mockImplementation(() => { });
+        await (0, package_installer_1.installAllPackageBundles)(dc, deps);
+        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to install bundles for failing-pkg"), expect.any(Error));
+        // pkg2 still got installed
+        expect(mockSignAndSavePV).toHaveBeenCalledTimes(1);
+        consoleSpy.mockRestore();
+    });
+});
+describe("getPackageLocalPath (via installPackageFromBundles)", () => {
+    it("awaits loadingPromise before reading value", async () => {
+        const packageId = (0, utils_1.newid)();
+        const resolvedPath = `/custom/${packageId}`;
+        let loadingResolved = false;
+        const files = {
+            [`${resolvedPath}/package.json`]: JSON.stringify({ name: "x", version: "1.0.0" }),
+            [`${resolvedPath}/dist/package.bundle.js`]: "code",
+        };
+        const deps = makeMockDeps(files);
+        const dc = mockDataContext();
+        // Simulate loadingPromise that resolves asynchronously
+        const loadingPromise = new Promise((resolve) => {
+            setTimeout(() => {
+                loadingResolved = true;
+                resolve();
+            }, 10);
+        });
+        mockGroupDeviceVar.mockReturnValue(Object.assign(() => resolvedPath, { loadingPromise }));
+        mockFindOnePV.mockResolvedValue(undefined);
+        mockFindOneFile.mockResolvedValue(undefined);
+        mockGetPkg.mockResolvedValue({
+            packageId,
+            name: "x",
+            description: "",
+            signature: "",
+            createdBy: "u",
+        });
+        await (0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, {
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(loadingResolved).toBe(true);
+    });
+    it("falls back to packagesRootDir when pvar returns undefined", async () => {
+        const packageId = (0, utils_1.newid)();
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        mockGroupDeviceVar.mockReturnValue(Object.assign(() => undefined, { loadingPromise: Promise.resolve() }));
+        // Since resolvePath just joins, and packagesRootDir = "/packages",
+        // the resolved path will be "/packages" — which won't have bundles.
+        // This should throw "Package directory does not exist"
+        await expect((0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, { skipLoad: true, skipResolve: true })).rejects.toThrow("Package directory does not exist");
+    });
+});