@peers-app/peers-sdk 0.18.8 → 0.19.6

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

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const package_cloner_1 = require("./package-cloner");
+// --- Mocks for SDK internals ---
+const mockSignAndSavePkg = jest.fn();
+jest.mock("../data/packages", () => ({
+    Packages: () => ({
+        signAndSave: mockSignAndSavePkg,
+    }),
+}));
+const mockGroupDeviceVar = jest.fn();
+jest.mock("../data/persistent-vars", () => ({
+    groupDeviceVar: (...args) => mockGroupDeviceVar(...args),
+}));
+const mockInstallPackageFromBundles = jest.fn();
+const mockGetPackageInfo = jest.fn();
+jest.mock("./package-installer", () => ({
+    installPackageFromBundles: (...args) => mockInstallPackageFromBundles(...args),
+    getPackageInfo: (...args) => mockGetPackageInfo(...args),
+}));
+// --- Test utilities ---
+function makeMockDeps(shellExec) {
+    return {
+        fs: {
+            readFile: jest.fn(async () => ""),
+            writeFile: jest.fn(async () => { }),
+            exists: jest.fn(async () => false),
+            readJson: jest.fn(async () => ({})),
+        },
+        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("deriveRepoSlug", () => {
+    it("extracts slug from https URL with .git suffix", () => {
+        expect((0, package_cloner_1.deriveRepoSlug)("https://github.com/peers-app/groceries.git")).toBe("groceries");
+    });
+    it("extracts slug from https URL without .git suffix", () => {
+        expect((0, package_cloner_1.deriveRepoSlug)("https://github.com/user/my-pkg")).toBe("my-pkg");
+    });
+    it("handles SSH-style URLs", () => {
+        expect((0, package_cloner_1.deriveRepoSlug)("git@github.com:user/some-repo.git")).toBe("some-repo");
+    });
+    it("returns empty string for empty URL", () => {
+        expect((0, package_cloner_1.deriveRepoSlug)("")).toBe("");
+    });
+});
+describe("clonePackage", () => {
+    it("throws when git is not installed", async () => {
+        const shellExec = jest.fn(async (cmd) => {
+            if (cmd === "git --version")
+                throw new Error("not found");
+            return { stdout: "", stderr: "" };
+        });
+        const deps = makeMockDeps(shellExec);
+        const dc = mockDataContext();
+        await expect((0, package_cloner_1.clonePackage)(dc, deps, { remoteRepo: "https://github.com/peers-app/test.git" })).rejects.toThrow("git is not installed");
+    });
+    it("throws when npm is not installed", async () => {
+        const shellExec = jest.fn(async (cmd) => {
+            if (cmd === "npm --version")
+                throw new Error("not found");
+            return { stdout: "", stderr: "" };
+        });
+        const deps = makeMockDeps(shellExec);
+        const dc = mockDataContext();
+        await expect((0, package_cloner_1.clonePackage)(dc, deps, { remoteRepo: "https://github.com/peers-app/test.git" })).rejects.toThrow("npm is not installed");
+    });
+    it("clones, installs, builds, and registers a package with valid packageId", async () => {
+        const deps = makeMockDeps();
+        const dc = mockDataContext();
+        // Directory doesn't exist
+        deps.fs.exists.mockResolvedValue(false);
+        // After clone, getPackageInfo returns a valid package
+        mockGetPackageInfo.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            name: "groceries",
+            description: "Shopping list app",
+        });
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
+        const mockPv = { packageVersionId: "pv001" };
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: mockPv,
+            loaded: undefined,
+            unchanged: false,
+        });
+        const result = await (0, package_cloner_1.clonePackage)(dc, deps, {
+            remoteRepo: "https://github.com/peers-app/groceries.git",
+        });
+        // Verify clone
+        expect(deps.shell.exec).toHaveBeenCalledWith("git clone https://github.com/peers-app/groceries.git /packages/groceries");
+        // Verify install + build
+        expect(deps.shell.exec).toHaveBeenCalledWith("npm install", { cwd: "/packages/groceries" });
+        expect(deps.shell.exec).toHaveBeenCalledWith("npm run build", { cwd: "/packages/groceries" });
+        // Verify package record was created (peers-app org = not disabled)
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            name: "groceries",
+            description: "Shopping list app",
+            disabled: false,
+            remoteRepo: "https://github.com/peers-app/groceries.git",
+        }), { restoreIfDeleted: true, saveAsSnapshot: true });
+        // Verify device var
+        expect(pvarSetter).toHaveBeenCalledWith("/packages/groceries");
+        // Verify install
+        expect(mockInstallPackageFromBundles).toHaveBeenCalledWith(dc, deps, "00mnkoyo7mizav6tseubjzr3a", { localPath: "/packages/groceries" });
+        expect(result.packageId).toBe("00mnkoyo7mizav6tseubjzr3a");
+        expect(result.localPath).toBe("/packages/groceries");
+        expect(result.remoteRepo).toBe("https://github.com/peers-app/groceries.git");
+        expect(result.packageVersion).toBe(mockPv);
+    });
+    it("auto-disables packages from non-peers-app orgs", async () => {
+        const deps = makeMockDeps();
+        const dc = mockDataContext();
+        deps.fs.exists.mockResolvedValue(false);
+        mockGetPackageInfo.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3b",
+            name: "external-pkg",
+        });
+        mockGroupDeviceVar.mockReturnValue(jest.fn());
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        await (0, package_cloner_1.clonePackage)(dc, deps, {
+            remoteRepo: "https://github.com/some-user/external-pkg.git",
+        });
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({ disabled: true }), expect.any(Object));
+    });
+    it("respects explicit disabled override", async () => {
+        const deps = makeMockDeps();
+        const dc = mockDataContext();
+        deps.fs.exists.mockResolvedValue(false);
+        mockGetPackageInfo.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3c",
+            name: "forced-enabled",
+        });
+        mockGroupDeviceVar.mockReturnValue(jest.fn());
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        // External repo but explicitly enabled
+        await (0, package_cloner_1.clonePackage)(dc, deps, {
+            remoteRepo: "https://github.com/external/pkg.git",
+            disabled: false,
+        });
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({ disabled: false }), expect.any(Object));
+    });
+    it("skips build when skipBuild is true", async () => {
+        const deps = makeMockDeps();
+        const dc = mockDataContext();
+        deps.fs.exists.mockResolvedValue(false);
+        mockGetPackageInfo.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3d",
+            name: "prebuilt",
+        });
+        mockGroupDeviceVar.mockReturnValue(jest.fn());
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        await (0, package_cloner_1.clonePackage)(dc, deps, {
+            remoteRepo: "https://github.com/peers-app/prebuilt.git",
+            skipBuild: true,
+        });
+        const execCalls = deps.shell.exec.mock.calls.map((c) => c[0]);
+        expect(execCalls).toContain("git --version");
+        expect(execCalls).toContain("npm --version");
+        expect(execCalls).toContain("git clone https://github.com/peers-app/prebuilt.git /packages/prebuilt");
+        expect(execCalls).not.toContain("npm install");
+        expect(execCalls).not.toContain("npm run build");
+    });
+    it("generates packageId and patches package.json when repo has no valid ID", async () => {
+        const deps = makeMockDeps();
+        const dc = mockDataContext();
+        deps.fs.exists.mockResolvedValue(false);
+        // No valid packageId
+        mockGetPackageInfo.mockResolvedValue({
+            name: "no-id-package",
+            description: "A package without peers config",
+        });
+        // readJson returns a package.json without peers.packageId
+        deps.fs.readJson.mockResolvedValue({
+            name: "no-id-package",
+            version: "1.0.0",
+        });
+        mockGroupDeviceVar.mockReturnValue(jest.fn());
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        const result = await (0, package_cloner_1.clonePackage)(dc, deps, {
+            remoteRepo: "https://github.com/peers-app/no-id-package.git",
+        });
+        // Should have written a patched package.json
+        expect(deps.fs.writeFile).toHaveBeenCalledWith("/packages/no-id-package/package.json", expect.any(String));
+        const patchedJson = JSON.parse(deps.fs.writeFile.mock.calls[0][1]);
+        expect(patchedJson.peers.packageId).toMatch(/^[a-z0-9]{25}$/);
+        // Result should use the generated ID
+        expect(result.packageId).toMatch(/^[a-z0-9]{25}$/);
+    });
+    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);
+        mockGetPackageInfo.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3e",
+            name: "existing",
+        });
+        const mockPv = { packageVersionId: "pvexist" };
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: mockPv,
+            loaded: undefined,
+            unchanged: true,
+        });
+        const result = await (0, package_cloner_1.clonePackage)(dc, deps, {
+            remoteRepo: "https://github.com/peers-app/existing.git",
+        });
+        // Should NOT clone or build
+        const execCalls = deps.shell.exec.mock.calls.map((c) => c[0]);
+        expect(execCalls).not.toContain(expect.stringContaining("git clone"));
+        expect(execCalls).not.toContain("npm install");
+        // Should delegate
+        expect(mockInstallPackageFromBundles).toHaveBeenCalled();
+        expect(result.packageId).toBe("00mnkoyo7mizav6tseubjzr3e");
+    });
+    it("throws when directory exists but has no valid packageId", async () => {
+        const deps = makeMockDeps();
+        const dc = mockDataContext();
+        deps.fs.exists.mockResolvedValue(true);
+        mockGetPackageInfo.mockResolvedValue({ name: "invalid-pkg" });
+        await expect((0, package_cloner_1.clonePackage)(dc, deps, { remoteRepo: "https://github.com/user/invalid-pkg.git" })).rejects.toThrow("does not contain a valid Peers package");
+    });
+    it("uses custom location when provided", async () => {
+        const deps = makeMockDeps();
+        const dc = mockDataContext();
+        deps.fs.exists.mockResolvedValue(false);
+        mockGetPackageInfo.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3f",
+            name: "custom-loc",
+        });
+        mockGroupDeviceVar.mockReturnValue(jest.fn());
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        await (0, package_cloner_1.clonePackage)(dc, deps, {
+            remoteRepo: "https://github.com/peers-app/test.git",
+            location: "/custom/install/path",
+        });
+        expect(deps.shell.exec).toHaveBeenCalledWith("git clone https://github.com/peers-app/test.git /custom/install/path");
+        expect(deps.shell.exec).toHaveBeenCalledWith("npm install", { cwd: "/custom/install/path" });
+    });
+});

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

@@ -0,0 +1,22 @@
+import type { DataContext } from "../context/data-context";
+import type { ICreatePackageOpts, ICreatePackageResult, IPackageInstallerDeps } from "./types";
+/**
+ * Convert a human-readable package name to a filesystem-safe folder slug.
+ * "My Widget" → "my-widget", "camelCase Thing" → "camel-case-thing"
+ */
+export declare function nameToFolderSlug(name: string): string;
+/**
+ * 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.
+ */
+export declare function ensureTemplateCache(deps: IPackageInstallerDeps, templateRepo: string): Promise<string>;
+/**
+ * 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.
+ */
+export declare function createPackage(dataContext: DataContext, deps: IPackageInstallerDeps, opts: ICreatePackageOpts): Promise<ICreatePackageResult>;

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