@peers-app/peers-sdk 0.27.2 → 0.27.4

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

@@ -1,908 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const system_ids_1 = require("../system-ids");
-const utils_1 = require("../utils");
-const package_creator_1 = require("./package-creator");
-const package_dev_tools_1 = require("./package-dev-tools");
-// --- Mocks for SDK internals ---
-const mockSignAndSavePkg = jest.fn();
-const mockGetPkg = jest.fn();
-jest.mock("../data/packages", () => ({
-    Packages: (dataContext) => ({
-        signAndSave: (...args) => mockSignAndSavePkg(dataContext, ...args),
-        get: (packageId) => mockGetPkg(dataContext, packageId),
-    }),
-}));
-const mockGroupDeviceVar = jest.fn();
-const mockPersistentVarsSave = jest.fn();
-const mockPersistentVarsFindOne = jest.fn();
-jest.mock("../data/persistent-vars", () => ({
-    groupDeviceVar: (...args) => mockGroupDeviceVar(...args),
-    PersistentVars: () => ({
-        save: mockPersistentVarsSave,
-        findOne: mockPersistentVarsFindOne,
-    }),
-}));
-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),
-}));
-const { newKeys: realNewKeys } = jest.requireActual("../keys");
-const generatedKeys = realNewKeys();
-const sourceKeys = realNewKeys();
-const targetKeys = realNewKeys();
-// --- 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 {
-        dataContextId: (0, utils_1.newid)(),
-        packageLoader: {
-            loadPackage: jest.fn().mockResolvedValue(undefined),
-        },
-    };
-}
-// --- Tests ---
-beforeEach(() => {
-    jest.clearAllMocks();
-    mockGetPkg.mockReset().mockResolvedValue(undefined);
-    mockPersistentVarsFindOne.mockReset().mockResolvedValue(undefined);
-    mockNewKeys.mockReturnValue(generatedKeys);
-    mockPersistentVarsSave.mockReset();
-});
-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");
-    });
-    it("preserves non-ASCII names and allocates a folder for symbol-only names", () => {
-        expect((0, package_creator_1.nameToFolderSlug)("買い物")).toBe("買い物");
-        expect((0, package_creator_1.nameToFolderSlug)("Café 漢字")).toBe("caf"); // Keep older creators' folder names.
-        const first = (0, package_creator_1.nameToFolderSlug)("🛒");
-        expect(first).toMatch(/^package-[a-z0-9]{25}$/);
-        expect((0, package_creator_1.nameToFolderSlug)("🛒")).not.toBe(first);
-    });
-    it("keeps long ASCII and Unicode names within a filesystem component's byte limit", () => {
-        for (const name of ["Long Name ".repeat(40), "漢".repeat(100)]) {
-            const folder = (0, package_creator_1.nameToFolderSlug)(name);
-            expect(Buffer.byteLength(folder, "utf8")).toBeLessThanOrEqual(255);
-            expect((0, package_creator_1.nameToFolderSlug)(name)).toBe(folder);
-            expect((0, package_creator_1.nameToFolderSlug)(`${name}more`)).not.toBe(folder);
-        }
-    });
-});
-describe("createPackage", () => {
-    it("fails before scaffolding when Node.js or npm is missing", async () => {
-        const shellExec = jest.fn(async (cmd) => {
-            if (cmd === "npm --version") {
-                throw new Error("/bin/sh: npm: command not found");
-            }
-            return { stdout: "", stderr: "" };
-        });
-        const deps = makeMockDeps({}, shellExec);
-        deps.fs.exists.mockResolvedValue(false);
-        await expect((0, package_creator_1.createPackage)(mockDataContext(), deps, { name: "KidsTube" })).rejects.toThrow(package_dev_tools_1.MISSING_NODE_MESSAGE);
-        expect(deps.fs.writeFile).not.toHaveBeenCalled();
-        expect(shellExec.mock.calls.map((call) => call[0])).toEqual([
-            "git --version",
-            "node --version",
-            "npm --version",
-        ]);
-    });
-    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 idsContent = JSON.stringify({
-            packageId: "<package-id>",
-            packageName: "<package-name>",
-            screenId: "<app-screen-id>",
-            contractId: "<contract-id>",
-            stateObservableName: "state",
-        });
-        const deps = makeMockDeps({});
-        const dc = mockDataContext();
-        // Simulate: location and cache do not exist; ids.json exists after the template 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("ids.json"))
-                return true;
-            return false;
-        });
-        deps.fs.readJson.mockResolvedValue(JSON.parse(templatePkgJson));
-        deps.fs.readFile.mockResolvedValue(idsContent);
-        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]);
-        expect(execCalls.slice(0, 3)).toEqual(["git --version", "node --version", "npm --version"]);
-        // 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 the isolated package ID source was patched.
-        const idsWriteCall = deps.fs.writeFile.mock.calls.find((c) => c[0].includes("ids.json"));
-        expect(idsWriteCall).toBeTruthy();
-        const writtenIds = JSON.parse(idsWriteCall[1]);
-        expect(writtenIds.packageId).toMatch(/^[a-z0-9]{25}$/);
-        expect(writtenIds.contractId).toMatch(/^[a-z0-9]{25}$/);
-        expect(writtenIds.screenId).toMatch(/^[a-z0-9]{25}$/);
-        expect(writtenIds.packageName).toBe("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(dc, 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);
-        expect(result.templateWarning).toBeUndefined();
-    });
-    it("returns a stale-template warning when the cached template cannot be refreshed", async () => {
-        const shellExec = jest.fn(async (cmd) => {
-            if (cmd === "git pull") {
-                throw new Error("error: Your local changes to the following files would be overwritten by merge:\n\t.gitignore");
-            }
-            return { stdout: "", stderr: "" };
-        });
-        const deps = makeMockDeps({}, shellExec);
-        const dc = mockDataContext();
-        deps.fs.exists.mockImplementation(async (path) => {
-            if (path === "/packages/desk")
-                return false;
-            if (path === "/packages/.peers-package-template")
-                return true;
-            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,
-        });
-        const result = await (0, package_creator_1.createPackage)(dc, deps, { name: "Desk" });
-        expect(result.templateWarning).toMatch(/stale version/i);
-        expect(result.templateWarning).toMatch(/local changes/i);
-        expect(result.localPath).toBe("/packages/desk");
-        expect(deps.shell.exec).toHaveBeenCalledWith("cp -r /packages/.peers-package-template/. /packages/desk");
-    });
-    it("registers metadata, path, and signing key when importing an existing package directory", async () => {
-        const deps = makeMockDeps({});
-        const dc = mockDataContext();
-        const personalCtx = mockDataContext();
-        deps.fs.exists.mockResolvedValue(true);
-        mockGetPackageInfo.mockResolvedValue({
-            packageId: "00mnkoyo7mizav6tseubjzr3a",
-            name: "existing-pkg",
-            description: "Imported package",
-        });
-        const pvarSetter = jest.fn();
-        mockGroupDeviceVar.mockReturnValue(pvarSetter);
-        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",
-            personalContext: personalCtx,
-        });
-        expect(deps.shell.exec).not.toHaveBeenCalled();
-        expect(mockGetPkg).toHaveBeenCalledWith(dc, "00mnkoyo7mizav6tseubjzr3a");
-        expect(mockNewKeys).toHaveBeenCalled();
-        expect(mockPersistentVarsSave).toHaveBeenCalledWith(expect.objectContaining({
-            name: "packageSigningKey_00mnkoyo7mizav6tseubjzr3a",
-            isSecret: true,
-            value: { value: generatedKeys.secretKey },
-        }), { restoreIfDeleted: true });
-        expect(mockSignAndSavePkg).toHaveBeenCalledWith(dc, expect.objectContaining({
-            packageId: "00mnkoyo7mizav6tseubjzr3a",
-            name: "Existing Pkg",
-            description: "Imported package",
-            publishPublicKey: generatedKeys.publicKey,
-        }), { restoreIfDeleted: true, saveAsSnapshot: true });
-        expect(mockGroupDeviceVar).toHaveBeenCalledWith("packageLocalPath_00mnkoyo7mizav6tseubjzr3a", expect.any(Object));
-        expect(pvarSetter).toHaveBeenCalledWith("/custom/path");
-        expect(mockInstallPackageFromBundles).toHaveBeenCalledWith(dc, deps, "00mnkoyo7mizav6tseubjzr3a", { localPath: "/custom/path" });
-        expect(result.packageId).toBe("00mnkoyo7mizav6tseubjzr3a");
-        expect(result.localPath).toBe("/custom/path");
-    });
-    it("reuses an existing publishPublicKey and does not rotate the signing key on re-import", async () => {
-        const deps = makeMockDeps({});
-        const dc = mockDataContext();
-        const personalCtx = mockDataContext();
-        deps.fs.exists.mockResolvedValue(true);
-        mockGetPackageInfo.mockResolvedValue({
-            packageId: "00mnkoyo7mizav6tseubjzr3a",
-            name: "existing-pkg",
-        });
-        mockGetPkg.mockResolvedValue({
-            packageId: "00mnkoyo7mizav6tseubjzr3a",
-            name: "existing-pkg",
-            description: "Old description",
-            createdBy: "00m87fbwu96jzf8qnwllly0fd",
-            publishPublicKey: "already-established-public-key",
-            signature: "sig",
-            disabled: false,
-        });
-        const pvarSetter = jest.fn();
-        mockGroupDeviceVar.mockReturnValue(pvarSetter);
-        mockInstallPackageFromBundles.mockResolvedValue({
-            packageVersion: { packageVersionId: "pv002", packageId: "00mnkoyo7mizav6tseubjzr3a" },
-            loaded: undefined,
-            unchanged: false,
-        });
-        await (0, package_creator_1.createPackage)(dc, deps, {
-            name: "existing-pkg",
-            location: "/custom/path",
-            personalContext: personalCtx,
-        });
-        expect(mockNewKeys).not.toHaveBeenCalled();
-        expect(mockPersistentVarsSave).not.toHaveBeenCalled();
-        expect(mockSignAndSavePkg).toHaveBeenCalledWith(dc, expect.objectContaining({
-            publishPublicKey: "already-established-public-key",
-            createdBy: "00m87fbwu96jzf8qnwllly0fd",
-        }), expect.any(Object));
-    });
-    describe("importing by name across contexts", () => {
-        const packageId = "00mnkoyo7mizav6tseubjzr3a";
-        let contexts;
-        let deps;
-        beforeEach(() => {
-            contexts = {
-                personal: mockDataContext(),
-                blankGroup: mockDataContext(),
-                group: mockDataContext(),
-                otherGroup: mockDataContext(),
-            };
-            const userContext = {
-                userId: contexts.personal.dataContextId,
-                userDataContext: contexts.personal,
-                groupDataContexts: new Map(Object.values(contexts)
-                    .slice(1)
-                    .map((dc) => [dc.dataContextId, dc])),
-            };
-            for (const dc of Object.values(contexts))
-                dc.userContext = userContext;
-            deps = makeMockDeps({ "/packages/existing-pkg/package.json": "{}" });
-            mockGetPackageInfo.mockResolvedValue({ packageId, description: "Imported package" });
-            mockGroupDeviceVar.mockReturnValue(jest.fn());
-            mockInstallPackageFromBundles.mockResolvedValue({ packageVersion: { packageId } });
-            mockPersistentVarsFindOne.mockResolvedValue({ value: { value: "unreadable-secret" } });
-        });
-        it.each([
-            ["group", "personal", ["personal", "blankGroup", "group"]],
-            ["group", "otherGroup", ["otherGroup", "personal", "blankGroup", "group"]],
-            ["personal", "group", ["group", "personal"]],
-        ])("reuses the key from %s when importing into %s", async (source, target, lookups) => {
-            mockGetPkg.mockImplementation(async (dc, id) => {
-                if (id !== packageId || dc === contexts[target])
-                    return undefined;
-                if (dc === contexts[source]) {
-                    return {
-                        publishPublicKey: sourceKeys.publicKey,
-                        name: "Source name",
-                        description: "Source description",
-                        createdBy: (0, utils_1.newid)(),
-                        disabled: true,
-                        activePackageVersionId: (0, utils_1.newid)(),
-                        versionFollowRange: "^1.0.0",
-                        followVersionTags: ["stable"],
-                        updateUrl: "source-url",
-                        remoteRepo: "source-repo",
-                        signature: "source-signature",
-                    };
-                }
-                if (dc === contexts.personal || dc === contexts.blankGroup) {
-                    return { publishPublicKey: " \t " };
-                }
-                return undefined;
-            });
-            const result = await (0, package_creator_1.createPackage)(contexts[target], deps, {
-                name: "Existing Pkg",
-                personalContext: contexts.personal,
-            });
-            expect(mockGetPkg.mock.calls).toEqual(lookups.map((name) => [contexts[name], packageId]));
-            expect(mockSignAndSavePkg).toHaveBeenCalledWith(contexts[target], expect.objectContaining({
-                packageId,
-                name: "Existing Pkg",
-                description: "Imported package",
-                publishPublicKey: sourceKeys.publicKey,
-                createdBy: system_ids_1.peersRootUserId,
-                disabled: false,
-                activePackageVersionId: undefined,
-                versionFollowRange: undefined,
-                followVersionTags: undefined,
-                updateUrl: undefined,
-                remoteRepo: undefined,
-                signature: "",
-            }), { restoreIfDeleted: true, saveAsSnapshot: true });
-            expect(mockInstallPackageFromBundles).toHaveBeenCalledWith(contexts[target], deps, packageId, {
-                localPath: "/packages/existing-pkg",
-            });
-            expect(result.packageVersion).toEqual({ packageId });
-            expect(mockNewKeys).not.toHaveBeenCalled();
-            expect(mockPersistentVarsSave).toHaveBeenCalledWith(expect.objectContaining({
-                value: { value: "unreadable-secret" },
-                description: expect.stringContaining(`v1:${packageId}:${sourceKeys.publicKey}`),
-            }));
-        });
-        it("keeps the target key without looking up a differing source key", async () => {
-            mockGetPkg.mockImplementation(async (dc) => ({
-                publishPublicKey: dc === contexts.otherGroup ? targetKeys.publicKey : sourceKeys.publicKey,
-            }));
-            await (0, package_creator_1.createPackage)(contexts.otherGroup, deps, {
-                name: "Existing Pkg",
-                personalContext: contexts.personal,
-            });
-            expect(mockGetPkg.mock.calls).toEqual([[contexts.otherGroup, packageId]]);
-            expect(mockSignAndSavePkg).toHaveBeenCalledWith(contexts.otherGroup, expect.objectContaining({ publishPublicKey: targetKeys.publicKey }), expect.any(Object));
-            expect(mockNewKeys).not.toHaveBeenCalled();
-            expect(mockPersistentVarsSave).toHaveBeenCalledWith(expect.objectContaining({
-                value: { value: "unreadable-secret" },
-                description: expect.stringContaining(`v1:${packageId}:${targetKeys.publicKey}`),
-            }));
-        });
-        it.each([
-            "missing",
-            "mismatch",
-            "lookup-error",
-            "empty-target",
-        ])("fails without installing or changing keys for %s", async (failure) => {
-            mockGetPkg.mockImplementation(async (dc) => {
-                if (dc === contexts.otherGroup) {
-                    return failure === "empty-target" ? { publishPublicKey: "" } : undefined;
-                }
-                if (failure === "lookup-error")
-                    throw new Error("source lookup failed");
-                return failure === "missing" ? undefined : { publishPublicKey: sourceKeys.publicKey };
-            });
-            if (failure === "mismatch") {
-                const { newKeys: realNewKeys } = jest.requireActual("../keys");
-                mockPersistentVarsFindOne.mockResolvedValue({ value: { value: realNewKeys().secretKey } });
-            }
-            await expect((0, package_creator_1.createPackage)(contexts.otherGroup, deps, {
-                name: "Existing Pkg",
-                personalContext: contexts.personal,
-            })).rejects.toThrow(failure === "mismatch"
-                ? "signing key mismatch"
-                : failure === "lookup-error"
-                    ? "source lookup failed"
-                    : "secret could not be hydrated");
-            if (failure === "empty-target") {
-                expect(mockGetPkg.mock.calls).toEqual([[contexts.otherGroup, packageId]]);
-            }
-            expect(mockSignAndSavePkg).not.toHaveBeenCalled();
-            expect(mockInstallPackageFromBundles).not.toHaveBeenCalled();
-            expect(mockNewKeys).not.toHaveBeenCalled();
-            expect(mockPersistentVarsSave).not.toHaveBeenCalled();
-        });
-    });
-    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("fills in the template's consts.ts and README, with the name as one string expression", async () => {
-        const template = {
-            "/packages/x/src/consts.ts": [
-                'export const packageId = "<package-id>";',
-                'export const packageName = "<package-name>";',
-                'export const contractId = "<contract-id>";',
-                'export const appScreenId = "<app-screen-id>";',
-            ].join("\n"),
-            "/packages/x/README.md": "# <package-name>\n",
-            "/packages/x/src/ids.json": '{"packageName":"<package-name>","packageId":"<package-id>"}',
-        };
-        async function create(name) {
-            const deps = makeMockDeps({});
-            deps.fs.exists.mockImplementation(async (path) => path in template);
-            deps.fs.readFile.mockImplementation(async (path) => template[path]);
-            deps.fs.readJson.mockResolvedValue({ name: "template", peers: {} });
-            mockGroupDeviceVar.mockReturnValue(jest.fn());
-            mockInstallPackageFromBundles.mockResolvedValue({
-                packageVersion: { packageVersionId: "pv" },
-                loaded: undefined,
-                unchanged: false,
-            });
-            await (0, package_creator_1.createPackage)(mockDataContext(), deps, { name, location: "/packages/x" });
-            const written = (path) => deps.fs.writeFile.mock.calls.find((call) => call[0] === path)[1];
-            const consts = written("/packages/x/src/consts.ts");
-            const literal = /packageName = (.*);/.exec(consts)?.[1] ?? "";
-            return {
-                consts,
-                literal,
-                readme: written("/packages/x/README.md"),
-                ids: JSON.parse(written("/packages/x/src/ids.json")),
-            };
-        }
-        const plain = await create("My Widget");
-        expect(plain.literal).toBe('"My Widget"');
-        expect(plain.consts).toMatch(/packageId = "[a-z0-9]{25}";/);
-        expect(plain.consts).not.toContain("<");
-        expect(plain.readme).toBe("# My Widget\n");
-        expect((await create("Cash $& Carry")).readme).toBe("# Cash $& Carry\n");
-        // Quoted as Biome's formatter would, so a new package passes `npm run lint`.
-        for (const [name, literal] of [
-            ["Mark's List", `"Mark's List"`],
-            ['The "Best" List', `'The "Best" List'`],
-            [`Mark's "Best" \\ List`, `'Mark\\'s "Best" \\\\ List'`],
-            ["Cash $& Carry", `"Cash $& Carry"`],
-            ["Café 漢字 🥛", `"Café 漢字 🥛"`],
-            ["Line\u2028and\u2029paragraph", `"Line\\u2028and\\u2029paragraph"`],
-            ['Say "hi"\u2028twice', `'Say "hi"\\u2028twice'`],
-            ["A <package-name> <package-id>", `"A <package-name> <package-id>"`],
-        ]) {
-            const created = await create(name);
-            expect(created.literal).toBe(literal);
-            expect(new Function(`return ${created.literal};`)()).toBe(name);
-            expect(created.readme).toBe(`# ${name}\n`);
-            expect(created.ids.packageName).toBe(name);
-            expect(created.ids.packageId).toMatch(/^[a-z0-9]{25}$/);
-        }
-        for (const name of [
-            "List <!-- comments -->",
-            "List import( jokes",
-            "List import /* notes",
-            'List eval( "quoted" \\ 漢字\u2028',
-        ]) {
-            const created = await create(name);
-            expect(created.literal).toMatch(/^String\(JSON.parse\(/);
-            expect(created.literal).not.toMatch(/<!--|-->|\b(?:import|eval)\s*(?:\(|\/[/*])/);
-            expect(new Function(`return ${created.literal};`)()).toBe(name);
-            expect(created.ids.packageName).toBe(name);
-            expect(created.readme).toBe(`# ${name}\n`);
-        }
-    });
-    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,
-        });
-        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: generatedKeys.secretKey },
-            isSecret: true,
-            description: expect.stringContaining("Signed Pkg"),
-        }), { restoreIfDeleted: true });
-        // Verify publishPublicKey was set on the package record
-        expect(mockSignAndSavePkg).toHaveBeenCalledWith(dc, expect.objectContaining({
-            publishPublicKey: generatedKeys.publicKey,
-        }), 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(dc, expect.objectContaining({
-            publishPublicKey: "",
-        }), expect.any(Object));
-    });
-});
-describe("ensurePackageSigningKey", () => {
-    it("generates a key once when none exists", async () => {
-        const personalCtx = mockDataContext();
-        const publicKey = await (0, package_creator_1.ensurePackageSigningKey)({
-            personalContext: personalCtx,
-            packageId: "00mnkoyo7mizav6tseubjzr3a",
-            packageName: "Test Pkg",
-        });
-        expect(publicKey).toBe(generatedKeys.publicKey);
-        expect(mockNewKeys).toHaveBeenCalledTimes(1);
-        expect(mockPersistentVarsSave).toHaveBeenCalledTimes(1);
-        expect(mockPersistentVarsSave).toHaveBeenCalledWith(expect.objectContaining({
-            persistentVarId: (0, utils_1.deterministicPvarId)("packageSigningKey_00mnkoyo7mizav6tseubjzr3a"),
-            value: { value: generatedKeys.secretKey },
-            description: `Signing key for package "Test Pkg"\npeers-package-signing-key:v1:00mnkoyo7mizav6tseubjzr3a:${generatedKeys.publicKey}`,
-        }), { restoreIfDeleted: true });
-    });
-    it("reuses an established publishPublicKey without generating a new key", async () => {
-        const personalCtx = mockDataContext();
-        const publicKey = await (0, package_creator_1.ensurePackageSigningKey)({
-            personalContext: personalCtx,
-            packageId: "00mnkoyo7mizav6tseubjzr3a",
-            packageName: "Test Pkg",
-            existingPublishPublicKey: "established-key",
-        });
-        expect(publicKey).toBe("established-key");
-        expect(mockNewKeys).not.toHaveBeenCalled();
-        expect(mockPersistentVarsSave).not.toHaveBeenCalled();
-    });
-    it("throws on an unrecoverable public/private key mismatch", async () => {
-        const { newKeys: realNewKeys } = jest.requireActual("../keys");
-        const realKeys = realNewKeys();
-        const otherKeys = realNewKeys();
-        const personalCtx = mockDataContext();
-        mockPersistentVarsFindOne.mockResolvedValue({
-            name: "packageSigningKey_00mnkoyo7mizav6tseubjzr3a",
-            value: { value: realKeys.secretKey },
-            isSecret: true,
-        });
-        await expect((0, package_creator_1.ensurePackageSigningKey)({
-            personalContext: personalCtx,
-            packageId: "00mnkoyo7mizav6tseubjzr3a",
-            packageName: "Test Pkg",
-            existingPublishPublicKey: otherKeys.publicKey,
-        })).rejects.toThrow("signing key mismatch");
-        expect(mockNewKeys).not.toHaveBeenCalled();
-    });
-});
-describe("signing key recovery after uninstall", () => {
-    const packageId = "00mnkoyo7mizav6tseubjzr3a";
-    const marker = `peers-package-signing-key:v1:${packageId}:${generatedKeys.publicKey}`;
-    let record;
-    let deps;
-    let personalContext;
-    let target;
-    beforeEach(() => {
-        personalContext = mockDataContext();
-        target = mockDataContext();
-        record = {
-            persistentVarId: (0, utils_1.deterministicPvarId)(`packageSigningKey_${packageId}`),
-            name: `packageSigningKey_${packageId}`,
-            scope: "user",
-            isSecret: true,
-            value: { value: "encrypted-secret~nonce" },
-            description: 'Signing key for package "Test Pkg"',
-            modifiedAt: 123,
-        };
-        mockPersistentVarsFindOne.mockImplementation(async () => record);
-        mockPersistentVarsSave.mockImplementation(async (saved) => {
-            record = saved;
-        });
-        deps = makeMockDeps({ "/packages/test-pkg/package.json": "{}" });
-        mockGetPackageInfo.mockResolvedValue({ packageId, name: "test-pkg" });
-        mockGroupDeviceVar.mockReturnValue(jest.fn());
-        mockInstallPackageFromBundles.mockResolvedValue({ packageVersion: { packageId } });
-    });
-    async function importPackage(resolveSigningPublicKey) {
-        return (0, package_creator_1.createPackage)(target, deps, {
-            name: "Test Pkg",
-            personalContext,
-            resolveSigningPublicKey,
-        });
-    }
-    function expectNoWrites() {
-        expect(mockPersistentVarsSave).not.toHaveBeenCalled();
-        expect(mockNewKeys).not.toHaveBeenCalled();
-        expect(mockSignAndSavePkg).not.toHaveBeenCalled();
-        expect(mockGroupDeviceVar).not.toHaveBeenCalled();
-        expect(mockInstallPackageFromBundles).not.toHaveBeenCalled();
-    }
-    it("recovers a cached public key with no Packages row or decryption callback", async () => {
-        record.description += `\n${marker}`;
-        await importPackage();
-        expect(mockSignAndSavePkg).toHaveBeenCalledWith(target, expect.objectContaining({ publishPublicKey: generatedKeys.publicKey }), expect.any(Object));
-        expect(mockPersistentVarsSave).not.toHaveBeenCalled();
-        expect(mockNewKeys).not.toHaveBeenCalled();
-    });
-    it("recovers a legacy encrypted secret through the host and backfills only description once", async () => {
-        const original = { ...record };
-        const resolve = jest.fn(async () => generatedKeys.publicKey);
-        await importPackage(resolve);
-        expect(resolve).toHaveBeenCalledWith(original.value.value);
-        expect(mockPersistentVarsSave).toHaveBeenCalledWith({
-            ...original,
-            description: `${original.description}\n${marker}`,
-        });
-        await importPackage(resolve);
-        expect(mockPersistentVarsSave).toHaveBeenCalledTimes(1);
-        expect(record.value).toBe(original.value);
-        expect(mockNewKeys).not.toHaveBeenCalled();
-    });
-    it("retains raw-secret hydration and backfills its public key without invoking the host", async () => {
-        record.value = { value: generatedKeys.secretKey };
-        const resolve = jest.fn();
-        await importPackage(resolve);
-        expect(resolve).not.toHaveBeenCalled();
-        expect(record.description).toContain(marker);
-        expect(record.value.value).toBe(generatedKeys.secretKey);
-    });
-    it.each([
-        "absent",
-        "throws",
-        "undefined",
-        "invalid",
-    ])("fails safely when host recovery is %s", async (mode) => {
-        const resolve = mode === "absent"
-            ? undefined
-            : jest.fn(async () => {
-                if (mode === "throws")
-                    throw new Error(`sensitive ${record.value.value} ${generatedKeys.secretKey}`);
-                return mode === "invalid" ? "not-a-public-key" : undefined;
-            });
-        await expect(importPackage(resolve)).rejects.toThrow(`Package "Test Pkg" (${packageId}) has a signing secret pvar but no recoverable publishPublicKey, ` +
-            "and the secret could not be hydrated. Restore publishPublicKey or unlock the signing secret before importing.");
-        expectNoWrites();
-    });
-    it.each([
-        "established",
-        "cached",
-    ])("uses the %s key when host decryption fails", async (source) => {
-        if (source === "cached")
-            record.description += `\n${marker}`;
-        else
-            mockGetPkg.mockResolvedValue({ publishPublicKey: generatedKeys.publicKey });
-        await importPackage(async () => {
-            throw new Error("decryption unavailable");
-        });
-        expect(record.description).toContain(marker);
-        expect(record.value.value).toBe("encrypted-secret~nonce");
-        expect(mockNewKeys).not.toHaveBeenCalled();
-    });
-    it.each([
-        "",
-        `peers-package-signing-key:v2:${packageId}:${generatedKeys.publicKey}`,
-        `peers-package-signing-key:v1:${(0, utils_1.newid)()}:${generatedKeys.publicKey}`,
-        `peers-package-signing-key:v1:${packageId}:invalid-key`,
-        `${marker}:extra`,
-        `prefix ${marker}`,
-        `${marker}\n${marker}`,
-    ])("does not trust malformed or unrelated metadata: %s", async (description) => {
-        record.description = description;
-        await expect(importPackage()).rejects.toThrow("secret could not be hydrated");
-        expectNoWrites();
-    });
-    it("repairs malformed metadata after recovering a valid key", async () => {
-        record.description += `\npeers-package-signing-key:v1:${packageId}:invalid`;
-        await importPackage(async () => generatedKeys.publicKey);
-        expect(record.description).toBe(`Signing key for package "Test Pkg"\n${marker}`);
-        expect(record.value.value).toBe("encrypted-secret~nonce");
-    });
-    it.each([
-        "established/cache",
-        "raw/cache",
-        "host/cache",
-        "host/established",
-    ])("rejects a %s mismatch before writes", async (source) => {
-        if (source.endsWith("cache"))
-            record.description += `\n${marker}`;
-        if (source.startsWith("established") || source.endsWith("established")) {
-            mockGetPkg.mockResolvedValue({ publishPublicKey: sourceKeys.publicKey });
-        }
-        if (source === "raw/cache")
-            record.value = { value: sourceKeys.secretKey };
-        const resolve = source.startsWith("host")
-            ? async () => (source.endsWith("cache") ? sourceKeys.publicKey : generatedKeys.publicKey)
-            : undefined;
-        await expect(importPackage(resolve)).rejects.toThrow("signing key mismatch");
-        expectNoWrites();
-    });
-});
-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.cachePath).toBe("/packages/.peers-package-template");
-        expect(result.warning).toBeUndefined();
-        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.cachePath).toBe("/packages/.peers-package-template");
-        expect(result.warning).toBeUndefined();
-        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("returns an offline warning when pull cannot reach the remote", async () => {
-        const shellExec = jest.fn(async (cmd) => {
-            if (cmd === "git pull") {
-                throw new Error("fatal: unable to access 'https://github.com/peers-app/peers-package-template.git'");
-            }
-            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");
-        expect(result.cachePath).toBe("/packages/.peers-package-template");
-        expect(result.refreshFailure).toBe("offline");
-        expect(result.warning).toMatch(/could not be reached/i);
-    });
-    it("returns a could-not-refresh warning when pull fails for local git reasons", async () => {
-        const shellExec = jest.fn(async (cmd) => {
-            if (cmd === "git pull") {
-                throw new Error("error: Your local changes to the following files would be overwritten by merge:\n\t.gitignore");
-            }
-            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");
-        expect(result.cachePath).toBe("/packages/.peers-package-template");
-        expect(result.refreshFailure).toBe("could-not-refresh");
-        expect(result.warning).toMatch(/stale version/i);
-        expect(result.warning).toMatch(/overwritten by merge/i);
-    });
-});
-describe("classifyTemplatePullFailure", () => {
-    it("treats unreachable remotes as offline", () => {
-        expect((0, package_creator_1.classifyTemplatePullFailure)(new Error("fatal: unable to access remote"))).toBe("offline");
-        expect((0, package_creator_1.classifyTemplatePullFailure)(new Error("Could not resolve host: github.com"))).toBe("offline");
-    });
-    it("treats dirty trees and auth problems as could-not-refresh", () => {
-        expect((0, package_creator_1.classifyTemplatePullFailure)(new Error("Your local changes to the following files would be overwritten by merge"))).toBe("could-not-refresh");
-        expect((0, package_creator_1.classifyTemplatePullFailure)(new Error("Permission denied (publickey)"))).toBe("could-not-refresh");
-    });
-});