@peers-app/peers-sdk 0.18.8 → 0.19.6

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

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const package_creator_1 = require("./package-creator");
+// --- Mocks for SDK internals ---
+const mockSignAndSavePkg = jest.fn();
+jest.mock("../data/packages", () => ({
+    Packages: () => ({
+        signAndSave: mockSignAndSavePkg,
+    }),
+}));
+const mockGroupDeviceVar = jest.fn();
+const mockPersistentVarsSave = jest.fn();
+jest.mock("../data/persistent-vars", () => ({
+    groupDeviceVar: (...args) => mockGroupDeviceVar(...args),
+    PersistentVars: () => ({
+        save: mockPersistentVarsSave,
+    }),
+}));
+const mockNewKeys = jest.fn();
+jest.mock("../keys", () => {
+    const actual = jest.requireActual("../keys");
+    return {
+        ...actual,
+        newKeys: (...args) => mockNewKeys(...args),
+    };
+});
+// Mock installPackageFromBundles and getPackageInfo from the same package
+const mockInstallPackageFromBundles = jest.fn();
+const mockGetPackageInfo = jest.fn();
+jest.mock("./package-installer", () => ({
+    installPackageFromBundles: (...args) => mockInstallPackageFromBundles(...args),
+    getPackageInfo: (...args) => mockGetPackageInfo(...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;
+                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() {
+    return {
+        packageLoader: {
+            loadPackage: jest.fn().mockResolvedValue(undefined),
+        },
+    };
+}
+// --- Tests ---
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+describe("nameToFolderSlug", () => {
+    it("converts a simple name", () => {
+        expect((0, package_creator_1.nameToFolderSlug)("My Widget")).toBe("my-widget");
+    });
+    it("converts camelCase names", () => {
+        expect((0, package_creator_1.nameToFolderSlug)("camelCaseThing")).toBe("camel-case-thing");
+    });
+    it("strips special characters", () => {
+        expect((0, package_creator_1.nameToFolderSlug)("Hello! World?")).toBe("hello-world");
+    });
+    it("collapses multiple spaces", () => {
+        expect((0, package_creator_1.nameToFolderSlug)("too   many   spaces")).toBe("too-many-spaces");
+    });
+});
+describe("createPackage", () => {
+    it("creates a package using local template cache with correct steps", async () => {
+        const templatePkgJson = JSON.stringify({
+            name: "peers-package-template",
+            version: "1.0.0",
+            peers: {},
+            repository: { url: "https://github.com/peers-app/peers-package-template" },
+        });
+        const constsContent = 'export const packageId = "<package-id>";\n' +
+            'export const packageName = "<package-name>";\n' +
+            'export const appScreenId = "<app-screen-id>";\n' +
+            'export const contractId = "<contract-id>";\n';
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        // Simulate: location doesn't exist, cache doesn't exist either, consts.ts exists after copy
+        deps.fs.exists.mockImplementation(async (path) => {
+            if (path === "/packages/my-widget")
+                return false;
+            if (path === "/packages/.peers-package-template")
+                return false;
+            if (path.includes("consts.ts"))
+                return true;
+            return false;
+        });
+        deps.fs.readJson.mockResolvedValue(JSON.parse(templatePkgJson));
+        deps.fs.readFile.mockResolvedValue(constsContent);
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
+        const mockPv = { packageVersionId: "pv001", packageId: "pkg001" };
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: mockPv,
+            loaded: undefined,
+            unchanged: false,
+        });
+        const result = await (0, package_creator_1.createPackage)(dc, deps, {
+            name: "My Widget",
+            author: "Test User",
+        });
+        const execCalls = deps.shell.exec.mock.calls.map((c) => c[0]);
+        // Verify template was cloned to cache (not directly to location)
+        expect(execCalls).toContain("git clone https://github.com/peers-app/peers-package-template.git /packages/.peers-package-template");
+        // Verify cp -r from cache to location
+        expect(deps.shell.exec).toHaveBeenCalledWith("cp -r /packages/.peers-package-template/. /packages/my-widget");
+        // Should NOT have cloned directly to location
+        expect(execCalls).not.toContain(expect.stringContaining("git clone") && expect.stringContaining("/packages/my-widget"));
+        // Verify package.json was patched
+        expect(deps.fs.writeFile).toHaveBeenCalledWith("/packages/my-widget/package.json", expect.any(String));
+        const writtenPkgJson = JSON.parse(deps.fs.writeFile.mock.calls.find((c) => c[0].includes("package.json"))[1]);
+        expect(writtenPkgJson.name).toBe("my-widget");
+        expect(writtenPkgJson.author).toBe("Test User");
+        expect(writtenPkgJson.peers.packageId).toMatch(/^[a-z0-9]{25}$/);
+        expect(writtenPkgJson.repository).toBeUndefined();
+        // Verify consts.ts was patched
+        const constsWriteCall = deps.fs.writeFile.mock.calls.find((c) => c[0].includes("consts.ts"));
+        expect(constsWriteCall).toBeTruthy();
+        const writtenConsts = constsWriteCall[1];
+        expect(writtenConsts).not.toContain("<package-id>");
+        expect(writtenConsts).not.toContain("<package-name>");
+        expect(writtenConsts).not.toContain("<app-screen-id>");
+        expect(writtenConsts).not.toContain("<contract-id>");
+        expect(writtenConsts).toContain("My Widget");
+        // Verify initialization commands
+        expect(deps.shell.exec).toHaveBeenCalledWith("rm -rf .git", { cwd: "/packages/my-widget" });
+        expect(deps.shell.exec).toHaveBeenCalledWith("npm install", { cwd: "/packages/my-widget" });
+        expect(deps.shell.exec).toHaveBeenCalledWith("npm run build", { cwd: "/packages/my-widget" });
+        expect(deps.shell.exec).toHaveBeenCalledWith("git init", { cwd: "/packages/my-widget" });
+        expect(deps.shell.exec).toHaveBeenCalledWith("git add .", { cwd: "/packages/my-widget" });
+        expect(deps.shell.exec).toHaveBeenCalledWith('git commit -m "Initial commit"', {
+            cwd: "/packages/my-widget",
+        });
+        // Verify package record was created
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({
+            name: "My Widget",
+            disabled: false,
+        }), { restoreIfDeleted: true, saveAsSnapshot: true });
+        // Verify device var was set
+        expect(mockGroupDeviceVar).toHaveBeenCalledWith(expect.stringContaining("packageLocalPath_"), expect.any(Object));
+        expect(pvarSetter).toHaveBeenCalledWith("/packages/my-widget");
+        // Verify installPackageFromBundles was called
+        expect(mockInstallPackageFromBundles).toHaveBeenCalledWith(dc, deps, expect.any(String), {
+            localPath: "/packages/my-widget",
+        });
+        expect(result.localPath).toBe("/packages/my-widget");
+        expect(result.packageVersion).toBe(mockPv);
+    });
+    it("delegates to installPackageFromBundles when directory already exists with valid package", async () => {
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        // Location exists
+        deps.fs.exists.mockResolvedValue(true);
+        // getPackageInfo returns a valid packageId
+        mockGetPackageInfo.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            name: "existing-pkg",
+        });
+        const mockPv = { packageVersionId: "pv002", packageId: "00mnkoyo7mizav6tseubjzr3a" };
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: mockPv,
+            loaded: undefined,
+            unchanged: false,
+        });
+        const result = await (0, package_creator_1.createPackage)(dc, deps, {
+            name: "existing-pkg",
+            location: "/custom/path",
+        });
+        // Should NOT clone
+        expect(deps.shell.exec).not.toHaveBeenCalled();
+        // Should delegate to install
+        expect(mockInstallPackageFromBundles).toHaveBeenCalledWith(dc, deps, "00mnkoyo7mizav6tseubjzr3a", { localPath: "/custom/path" });
+        expect(result.packageId).toBe("00mnkoyo7mizav6tseubjzr3a");
+        expect(result.localPath).toBe("/custom/path");
+    });
+    it("throws when directory exists but has no valid package", async () => {
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        deps.fs.exists.mockResolvedValue(true);
+        mockGetPackageInfo.mockResolvedValue({ name: "no-id-pkg" });
+        await expect((0, package_creator_1.createPackage)(dc, deps, { name: "bad-pkg", location: "/some/path" })).rejects.toThrow("does not contain a valid Peers package");
+    });
+    it("uses direct clone (no caching) when custom templateRepo is provided", async () => {
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        deps.fs.exists.mockImplementation(async (path) => {
+            if (path === "/packages/my-pkg")
+                return false;
+            if (path.includes("consts.ts"))
+                return false;
+            return false;
+        });
+        deps.fs.readJson.mockResolvedValue({ name: "template", peers: {} });
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        await (0, package_creator_1.createPackage)(dc, deps, {
+            name: "My Pkg",
+            templateRepo: "https://example.com/custom-template.git",
+        });
+        // Custom template should clone directly to location (no cache, no cp -r)
+        expect(deps.shell.exec).toHaveBeenCalledWith("git clone https://example.com/custom-template.git /packages/my-pkg");
+        const execCalls = deps.shell.exec.mock.calls.map((c) => c[0]);
+        expect(execCalls).not.toContain(expect.stringContaining("cp -r"));
+        expect(execCalls).not.toContain(expect.stringContaining(".peers-package-template"));
+    });
+    it("uses custom location when provided", async () => {
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        deps.fs.exists.mockResolvedValue(false);
+        deps.fs.readJson.mockResolvedValue({ name: "template", peers: {} });
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        await (0, package_creator_1.createPackage)(dc, deps, {
+            name: "My Pkg",
+            location: "/custom/my-special-location",
+        });
+        expect(deps.shell.exec).toHaveBeenCalledWith(expect.stringContaining("/custom/my-special-location"));
+        expect(pvarSetter).toHaveBeenCalledWith("/custom/my-special-location");
+    });
+    it("generates a signing keypair and stores it when personalContext is provided", async () => {
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        const personalCtx = mockDataContext();
+        deps.fs.exists.mockImplementation(async (path) => {
+            if (path.includes("consts.ts"))
+                return false;
+            return false;
+        });
+        deps.fs.readJson.mockResolvedValue({ name: "template", peers: {} });
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        mockNewKeys.mockReturnValue({
+            publicKey: "test-public-key-abc",
+            secretKey: "test-secret-key-xyz",
+            publicBoxKey: "test-box-key",
+        });
+        await (0, package_creator_1.createPackage)(dc, deps, {
+            name: "Signed Pkg",
+            personalContext: personalCtx,
+        });
+        // Verify keypair was generated
+        expect(mockNewKeys).toHaveBeenCalled();
+        // Verify secret key was saved as a secret pvar in personal context
+        expect(mockPersistentVarsSave).toHaveBeenCalledWith(expect.objectContaining({
+            name: expect.stringMatching(/^packageSigningKey_[a-z0-9]{25}$/),
+            scope: "user",
+            value: { value: "test-secret-key-xyz" },
+            isSecret: true,
+            description: expect.stringContaining("Signed Pkg"),
+        }));
+        // Verify publishPublicKey was set on the package record
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({
+            publishPublicKey: "test-public-key-abc",
+        }), expect.any(Object));
+    });
+    it("skips key generation when personalContext is not provided", async () => {
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        deps.fs.exists.mockImplementation(async (path) => {
+            if (path.includes("consts.ts"))
+                return false;
+            return false;
+        });
+        deps.fs.readJson.mockResolvedValue({ name: "template", peers: {} });
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        await (0, package_creator_1.createPackage)(dc, deps, { name: "No Key Pkg" });
+        // Should NOT call newKeys
+        expect(mockNewKeys).not.toHaveBeenCalled();
+        // Should NOT save any pvar
+        expect(mockPersistentVarsSave).not.toHaveBeenCalled();
+        // publishPublicKey should be empty string
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({
+            publishPublicKey: "",
+        }), expect.any(Object));
+    });
+});
+describe("ensureTemplateCache", () => {
+    it("clones template when cache directory does not exist", async () => {
+        const deps = makeMockDeps({});
+        deps.fs.exists.mockResolvedValue(false);
+        const result = await (0, package_creator_1.ensureTemplateCache)(deps, "https://github.com/peers-app/peers-package-template.git");
+        expect(result).toBe("/packages/.peers-package-template");
+        expect(deps.shell.exec).toHaveBeenCalledWith("git clone https://github.com/peers-app/peers-package-template.git /packages/.peers-package-template");
+    });
+    it("pulls latest when cache directory already exists", async () => {
+        const deps = makeMockDeps({});
+        deps.fs.exists.mockResolvedValue(true);
+        const result = await (0, package_creator_1.ensureTemplateCache)(deps, "https://github.com/peers-app/peers-package-template.git");
+        expect(result).toBe("/packages/.peers-package-template");
+        expect(deps.shell.exec).toHaveBeenCalledWith("git pull", {
+            cwd: "/packages/.peers-package-template",
+        });
+        // Should NOT have cloned
+        const execCalls = deps.shell.exec.mock.calls.map((c) => c[0]);
+        expect(execCalls).not.toContain(expect.stringContaining("git clone"));
+    });
+    it("continues silently when pull fails (offline)", async () => {
+        const shellExec = jest.fn(async (cmd) => {
+            if (cmd === "git pull")
+                throw new Error("fatal: unable to access remote");
+            return { stdout: "", stderr: "" };
+        });
+        const deps = makeMockDeps({}, shellExec);
+        deps.fs.exists.mockResolvedValue(true);
+        const result = await (0, package_creator_1.ensureTemplateCache)(deps, "https://github.com/peers-app/peers-package-template.git");
+        // Should not throw, returns cache path
+        expect(result).toBe("/packages/.peers-package-template");
+    });
+});

package/dist/package-installer/package-installer.d.ts

@@ -0,0 +1,32 @@
+import type { DataContext } from "../context/data-context";
+import type { IInstallOpts, IInstallResult, IPackageInfo, IPackageInstallerDeps } from "./types";
+/**
+ * Install or update a dev PackageVersion from locally-built bundle files.
+ *
+ * This is the core workhorse of the package-installer module. It reads
+ * bundles from `dist/`, hashes them for deduplication, saves File records
+ * only when content has changed, upserts the PackageVersion, and optionally
+ * triggers the package loader and device version resolution.
+ */
+export declare function installPackageFromBundles(dataContext: DataContext, deps: IPackageInstallerDeps, packageId: string, opts?: IInstallOpts): Promise<IInstallResult>;
+/**
+ * Install bundles for all non-disabled packages in a data context.
+ * Errors are caught per-package so one failure doesn't block others.
+ */
+export declare function installAllPackageBundles(dataContext: DataContext, deps: IPackageInstallerDeps): Promise<void>;
+/**
+ * Save a bundle's content as a File record, deduplicating by hash.
+ *
+ * If a File with the same hash already exists for this bundle name,
+ * the existing record is reused — no new File is created. This eliminates
+ * the "new File record on every dev reload" bug.
+ */
+export declare function saveBundleFile(dataContext: DataContext, content: string, name: string, _packageId: string): Promise<{
+    fileId: string;
+    fileHash: string;
+}>;
+/**
+ * Read package metadata from a local package directory.
+ * Uses `deps.fs.readJson` instead of `require()` — no cache issues.
+ */
+export declare function getPackageInfo(deps: IPackageInstallerDeps, localPath: string): Promise<IPackageInfo>;

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

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPackageFromBundles = installPackageFromBundles;
+exports.installAllPackageBundles = installAllPackageBundles;
+exports.saveBundleFile = saveBundleFile;
+exports.getPackageInfo = getPackageInfo;
+const file_types_1 = require("../data/files/file.types");
+const files_1 = require("../data/files/files");
+const package_version_resolver_1 = require("../data/package-version-resolver");
+const package_versions_1 = require("../data/package-versions");
+const packages_1 = require("../data/packages");
+const persistent_vars_1 = require("../data/persistent-vars");
+const utils_1 = require("../utils");
+/**
+ * Install or update a dev PackageVersion from locally-built bundle files.
+ *
+ * This is the core workhorse of the package-installer module. It reads
+ * bundles from `dist/`, hashes them for deduplication, saves File records
+ * only when content has changed, upserts the PackageVersion, and optionally
+ * triggers the package loader and device version resolution.
+ */
+async function installPackageFromBundles(dataContext, deps, packageId, opts) {
+    const versionTag = opts?.versionTag ?? "dev";
+    // 1. Resolve local path
+    const localPath = opts?.localPath ?? (await getPackageLocalPath(packageId, dataContext, deps));
+    if (!(await deps.fs.exists(localPath))) {
+        throw new Error(`Package directory does not exist: ${localPath}`);
+    }
+    // 2. Read package info
+    const info = await getPackageInfo(deps, localPath);
+    const version = info.version ?? "0.0.1";
+    // 3. Read bundle files
+    const distDir = deps.resolvePath(localPath, "dist");
+    const packageBundlePath = deps.resolvePath(distDir, "package.bundle.js");
+    if (!(await deps.fs.exists(packageBundlePath))) {
+        throw new Error(`Required bundle not found: ${packageBundlePath}. Run 'npm run build' first.`);
+    }
+    const packageBundle = await deps.fs.readFile(packageBundlePath);
+    const routesBundlePath = deps.resolvePath(distDir, "routes.bundle.js");
+    const routesBundle = (await deps.fs.exists(routesBundlePath))
+        ? await deps.fs.readFile(routesBundlePath)
+        : undefined;
+    const uiBundlePath = deps.resolvePath(distDir, "uis.bundle.js");
+    const uiBundle = (await deps.fs.exists(uiBundlePath))
+        ? await deps.fs.readFile(uiBundlePath)
+        : undefined;
+    // 4. Hash each bundle (must match file-system hashes for signature consistency)
+    const packageHash = (0, file_types_1.computeFileHash)(packageBundle);
+    const routesHash = routesBundle ? (0, file_types_1.computeFileHash)(routesBundle) : undefined;
+    const uiHash = uiBundle ? (0, file_types_1.computeFileHash)(uiBundle) : undefined;
+    // 5. Compute PV hash
+    const pvHash = (0, package_versions_1.computePackageVersionHash)(version, "", packageHash, routesHash, uiHash);
+    // 6. Early exit if unchanged
+    const pvTable = (0, package_versions_1.PackageVersions)(dataContext);
+    const existingPv = await pvTable.findOne({ packageId, versionTag });
+    if (existingPv && existingPv.packageVersionHash === pvHash) {
+        return {
+            packageVersion: existingPv,
+            loaded: undefined,
+            unchanged: true,
+        };
+    }
+    // 7. Save bundle files (deduped by hash)
+    const packageFile = await saveBundleFile(dataContext, packageBundle, `${packageId}-package.bundle.js`, packageId);
+    let routesFile;
+    if (routesBundle) {
+        routesFile = await saveBundleFile(dataContext, routesBundle, `${packageId}-routes.bundle.js`, packageId);
+    }
+    let uiFile;
+    if (uiBundle) {
+        uiFile = await saveBundleFile(dataContext, uiBundle, `${packageId}-uis.bundle.js`, packageId);
+    }
+    // 8. Upsert PackageVersion
+    const now = new Date().toISOString();
+    const pv = {
+        packageVersionId: existingPv?.packageVersionId ?? (0, utils_1.newid)(),
+        packageId,
+        version,
+        versionTag,
+        packageVersionHash: pvHash,
+        packageBundleFileId: packageFile.fileId,
+        packageBundleFileHash: packageFile.fileHash,
+        routesBundleFileId: routesFile?.fileId,
+        routesBundleFileHash: routesFile?.fileHash,
+        uiBundleFileId: uiFile?.fileId,
+        uiBundleFileHash: uiFile?.fileHash,
+        appNavs: existingPv?.appNavs,
+        history: existingPv?.history,
+        signature: existingPv?.signature ?? "",
+        createdBy: existingPv?.createdBy ?? packageId,
+        createdAt: now,
+    };
+    const savedPv = await pvTable.signAndSave(pv);
+    // 9. Load package (unless skipLoad)
+    let loaded;
+    if (!opts?.skipLoad) {
+        const pkg = await (0, packages_1.Packages)(dataContext).get(packageId);
+        if (pkg) {
+            loaded = await dataContext.packageLoader.loadPackage(pkg, {
+                force: true,
+                localPath,
+                packageVersionId: savedPv.packageVersionId,
+            });
+            // Extract appNavs from loaded instance onto the PV
+            if (loaded?.appNavs && JSON.stringify(loaded.appNavs) !== JSON.stringify(savedPv.appNavs)) {
+                savedPv.appNavs = loaded.appNavs;
+                await pvTable.signAndSave(savedPv);
+            }
+        }
+    }
+    // 10. Update package description if info provides one and it differs
+    const pkg = await (0, packages_1.Packages)(dataContext).get(packageId);
+    if (pkg && info.description && info.description !== pkg.description) {
+        await (0, packages_1.Packages)(dataContext).signAndSave({
+            ...pkg,
+            description: info.description,
+        });
+    }
+    // 11. Activate on device (unless skipResolve)
+    if (!opts?.skipResolve && pkg) {
+        await (0, package_version_resolver_1.updatePackagePrefs)(packageId, { activePackageVersionId: savedPv.packageVersionId }, dataContext);
+        await (0, package_version_resolver_1.resolveDevicePackageVersion)(pkg, dataContext, {
+            force: true,
+            localPath,
+        });
+    }
+    return { packageVersion: savedPv, loaded, unchanged: false };
+}
+/**
+ * Install bundles for all non-disabled packages in a data context.
+ * Errors are caught per-package so one failure doesn't block others.
+ */
+async function installAllPackageBundles(dataContext, deps) {
+    const packages = await (0, packages_1.Packages)(dataContext).list();
+    for (const pkg of packages) {
+        if (pkg.disabled)
+            continue;
+        try {
+            await installPackageFromBundles(dataContext, deps, pkg.packageId);
+        }
+        catch (err) {
+            console.error(`[package-installer] Failed to install bundles for ${pkg.name} (${pkg.packageId}):`, err);
+        }
+    }
+}
+/**
+ * Save a bundle's content as a File record, deduplicating by hash.
+ *
+ * If a File with the same hash already exists for this bundle name,
+ * the existing record is reused — no new File is created. This eliminates
+ * the "new File record on every dev reload" bug.
+ */
+async function saveBundleFile(dataContext, content, name, _packageId) {
+    const fileHash = (0, file_types_1.computeFileHash)(content);
+    const filesTable = (0, files_1.Files)(dataContext);
+    // Check if a file with this hash already exists for this bundle name
+    const existing = await filesTable.findOne({ name, fileHash });
+    if (existing) {
+        return { fileId: existing.fileId, fileHash: existing.fileHash };
+    }
+    const fileId = (0, utils_1.newid)();
+    const metadata = {
+        fileId,
+        name,
+        fileSize: content.length,
+        mimeType: "application/javascript",
+    };
+    const saved = await filesTable.saveFile(metadata, content);
+    return { fileId: saved.fileId, fileHash: saved.fileHash };
+}
+/**
+ * Read package metadata from a local package directory.
+ * Uses `deps.fs.readJson` instead of `require()` — no cache issues.
+ */
+async function getPackageInfo(deps, localPath) {
+    const pkgJsonPath = deps.resolvePath(localPath, "package.json");
+    const pkgJson = await deps.fs.readJson(pkgJsonPath);
+    const info = {
+        packageId: pkgJson.peers?.packageId,
+        name: pkgJson.name ?? "unknown",
+        version: pkgJson.version,
+        description: pkgJson.description,
+    };
+    // Try to get a richer description from README
+    const readmePath = deps.resolvePath(localPath, "README.md");
+    if (await deps.fs.exists(readmePath)) {
+        try {
+            const readme = await deps.fs.readFile(readmePath);
+            const firstParagraph = extractReadmeDescription(readme);
+            if (firstParagraph) {
+                info.description = firstParagraph;
+            }
+        }
+        catch {
+            // README read failure is non-fatal
+        }
+    }
+    // Try to detect remoteRepo from git
+    try {
+        const { stdout } = await deps.shell.exec("git remote get-url origin", {
+            cwd: localPath,
+        });
+        const url = stdout.trim();
+        if (url) {
+            info.remoteRepo = url;
+        }
+    }
+    catch {
+        // No git remote is fine
+    }
+    return info;
+}
+/**
+ * Resolve the local filesystem path for a package based on device vars.
+ * Awaits the loading promise to ensure the DB-stored value is available
+ * before reading. Falls back to `{packagesRootDir}`.
+ */
+async function getPackageLocalPath(packageId, dataContext, deps) {
+    const pvar = (0, persistent_vars_1.groupDeviceVar)(`packageLocalPath_${packageId}`, {
+        defaultValue: deps.packagesRootDir,
+        dataContext,
+    });
+    await pvar.loadingPromise;
+    return deps.resolvePath(pvar() ?? deps.packagesRootDir);
+}
+/** Extract the first non-heading paragraph from a README as a description. */
+function extractReadmeDescription(readme) {
+    const lines = readme.split("\n");
+    let foundContent = false;
+    const descLines = [];
+    for (const line of lines) {
+        // Skip headings and blank lines at the start
+        if (!foundContent) {
+            if (line.startsWith("#") || line.trim() === "")
+                continue;
+            foundContent = true;
+        }
+        // Stop at the next heading or blank line after content
+        if (foundContent) {
+            if (line.startsWith("#") || (line.trim() === "" && descLines.length > 0))
+                break;
+            descLines.push(line.trim());
+        }
+    }
+    const desc = descLines.join(" ").trim();
+    return desc || undefined;
+}

package/dist/package-installer/package-installer.test.d.ts

@@ -0,0 +1 @@
+export {};