@peers-app/peers-sdk 0.18.8 → 0.19.0

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

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nameToFolderSlug = nameToFolderSlug;
+exports.ensureTemplateCache = ensureTemplateCache;
+exports.createPackage = createPackage;
+const packages_1 = require("../data/packages");
+const persistent_vars_1 = require("../data/persistent-vars");
+const keys_1 = require("../keys");
+const system_ids_1 = require("../system-ids");
+const utils_1 = require("../utils");
+const package_author_signing_1 = require("./package-author-signing");
+const package_installer_1 = require("./package-installer");
+const DEFAULT_TEMPLATE_REPO = "https://github.com/peers-app/peers-package-template.git";
+const TEMPLATE_CACHE_DIR = ".peers-package-template";
+/**
+ * Convert a human-readable package name to a filesystem-safe folder slug.
+ * "My Widget" → "my-widget", "camelCase Thing" → "camel-case-thing"
+ */
+function nameToFolderSlug(name) {
+    let slug = name.replace(/[^a-zA-Z0-9]/g, " ");
+    slug = slug.replace(/\s+/g, " ").trim();
+    return (0, utils_1.camelCaseToHyphens)(slug);
+}
+/**
+ * Ensure the package template is available locally.
+ * On first call, clones the template repo into a dot-prefixed cache directory.
+ * On subsequent calls, attempts a `git pull` to refresh (continues silently if offline).
+ * @returns The path to the cached template directory.
+ */
+async function ensureTemplateCache(deps, templateRepo) {
+    const cachePath = deps.resolvePath(deps.packagesRootDir, TEMPLATE_CACHE_DIR);
+    if (await deps.fs.exists(cachePath)) {
+        try {
+            await deps.shell.exec("git pull", { cwd: cachePath });
+        }
+        catch {
+            // Offline or remote unreachable — continue with stale cache
+        }
+    }
+    else {
+        await deps.shell.exec(`git clone ${templateRepo} ${cachePath}`);
+    }
+    return cachePath;
+}
+/**
+ * Create a new Peers package from the package template.
+ *
+ * Clones the template repo, patches IDs and metadata, runs npm install + build,
+ * initializes a fresh git repo, then delegates to {@link installPackageFromBundles}
+ * to register the dev bundle in the database.
+ */
+async function createPackage(dataContext, deps, opts) {
+    const location = opts.location ?? deps.resolvePath(deps.packagesRootDir, nameToFolderSlug(opts.name));
+    // If directory already exists, treat as an import rather than a fresh create
+    if (await deps.fs.exists(location)) {
+        const info = await (0, package_installer_1.getPackageInfo)(deps, location);
+        if (info.packageId) {
+            const result = await (0, package_installer_1.installPackageFromBundles)(dataContext, deps, info.packageId, {
+                localPath: location,
+            });
+            return {
+                packageId: info.packageId,
+                localPath: location,
+                packageVersion: result.packageVersion,
+            };
+        }
+        throw new Error(`Directory already exists at ${location} but does not contain a valid Peers package`);
+    }
+    // Generate fresh IDs
+    const packageId = (0, utils_1.newid)();
+    const contractId = (0, utils_1.newid)();
+    const appScreenId = (0, utils_1.newid)();
+    const templateRepo = opts.templateRepo ?? DEFAULT_TEMPLATE_REPO;
+    // Get template contents into location
+    if (opts.templateRepo && opts.templateRepo !== DEFAULT_TEMPLATE_REPO) {
+        // Custom template — clone directly (no caching)
+        await deps.shell.exec(`git clone ${templateRepo} ${location}`);
+    }
+    else {
+        // Default template — use local cache for speed and offline support
+        const cachePath = await ensureTemplateCache(deps, templateRepo);
+        await deps.shell.exec(`cp -r ${cachePath}/. ${location}`);
+    }
+    // Patch package.json
+    const packageJsonPath = deps.resolvePath(location, "package.json");
+    const packageObj = await deps.fs.readJson(packageJsonPath);
+    packageObj.peers = packageObj.peers || {};
+    packageObj.peers.packageId = packageId;
+    packageObj.name = (0, utils_1.camelCaseToHyphens)(opts.name);
+    if (opts.author) {
+        packageObj.author = opts.author;
+    }
+    delete packageObj.repository;
+    await deps.fs.writeFile(packageJsonPath, JSON.stringify(packageObj, null, 2));
+    // Patch src/consts.ts placeholders
+    const constsPath = deps.resolvePath(location, "src", "consts.ts");
+    if (await deps.fs.exists(constsPath)) {
+        let consts = await deps.fs.readFile(constsPath);
+        consts = consts
+            .replace("<package-name>", opts.name)
+            .replace("<package-id>", packageId)
+            .replace("<app-screen-id>", appScreenId)
+            .replace("<contract-id>", contractId);
+        await deps.fs.writeFile(constsPath, consts);
+    }
+    // Initialize as a new project: remove template git history, install, build, fresh git
+    await deps.shell.exec("rm -rf .git", { cwd: location });
+    await deps.shell.exec("npm install", { cwd: location });
+    await deps.shell.exec("npm run build", { cwd: location });
+    await deps.shell.exec("git init", { cwd: location });
+    await deps.shell.exec("git add .", { cwd: location });
+    await deps.shell.exec('git commit -m "Initial commit"', { cwd: location });
+    // Generate signing keypair and store secret in user's personal group
+    let publishPublicKey = "";
+    if (opts.personalContext) {
+        const keys = (0, keys_1.newKeys)();
+        publishPublicKey = keys.publicKey;
+        const keyName = `${package_author_signing_1.PACKAGE_SIGNING_KEY_PREFIX}${packageId}`;
+        await (0, persistent_vars_1.PersistentVars)(opts.personalContext).save({
+            persistentVarId: (0, utils_1.deterministicPvarId)(keyName),
+            name: keyName,
+            scope: "user",
+            value: { value: keys.secretKey },
+            isSecret: true,
+            description: `Signing key for package "${opts.name}"`,
+            modifiedAt: Date.now(),
+        });
+    }
+    // Register the package record
+    await (0, packages_1.Packages)(dataContext).signAndSave({
+        packageId,
+        name: opts.name,
+        description: "",
+        createdBy: system_ids_1.peersRootUserId,
+        disabled: false,
+        publishPublicKey,
+        signature: "",
+    }, { restoreIfDeleted: true, saveAsSnapshot: true });
+    // Set the packageLocalPath device var
+    const pvar = (0, persistent_vars_1.groupDeviceVar)(`packageLocalPath_${packageId}`, {
+        defaultValue: deps.packagesRootDir,
+        dataContext,
+    });
+    pvar(location);
+    // Install the dev bundle
+    const result = await (0, package_installer_1.installPackageFromBundles)(dataContext, deps, packageId, {
+        localPath: location,
+    });
+    return {
+        packageId,
+        localPath: location,
+        packageVersion: result.packageVersion,
+    };
+}

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

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

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>;