@peers-app/peers-sdk 0.19.9 → 0.19.12

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

@@ -7,4 +7,5 @@ export * from "./package-publisher";
 export * from "./package-remote-checker";
 export * from "./package-seed-installer";
 export * from "./package-tarball";
+export * from "./peers-core-installer";
 export * from "./types";

package/dist/package-installer/index.js

@@ -23,4 +23,5 @@ __exportStar(require("./package-publisher"), exports);
 __exportStar(require("./package-remote-checker"), exports);
 __exportStar(require("./package-seed-installer"), exports);
 __exportStar(require("./package-tarball"), exports);
+__exportStar(require("./peers-core-installer"), exports);
 __exportStar(require("./types"), exports);

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

@@ -136,7 +136,11 @@ async function installAllPackageBundles(dataContext, deps) {
         if (pkg.disabled)
             continue;
         try {
-            await installPackageFromBundles(dataContext, deps, pkg.packageId);
+            const localPath = await getPackageLocalPath(pkg.packageId, dataContext, deps);
+            if (!(await hasPackageJson(deps, localPath))) {
+                continue;
+            }
+            await installPackageFromBundles(dataContext, deps, pkg.packageId, { localPath });
         }
         catch (err) {
             console.error(`[package-installer] Failed to install bundles for ${pkg.name} (${pkg.packageId}):`, err);
@@ -210,18 +214,65 @@ async function getPackageInfo(deps, localPath) {
     }
     return info;
 }
-/**
- * Resolve the local filesystem path for a package based on device vars.
- * Awaits the loading promise to ensure the DB-stored value is available
- * before reading. Falls back to `{packagesRootDir}`.
- */
-async function getPackageLocalPath(packageId, dataContext, deps) {
+async function readPackageLocalPathPvar(packageId, dataContext, deps) {
     const pvar = (0, persistent_vars_1.groupDeviceVar)(`packageLocalPath_${packageId}`, {
         defaultValue: deps.packagesRootDir,
         dataContext,
     });
     await pvar.loadingPromise;
-    return deps.resolvePath(pvar() ?? deps.packagesRootDir);
+    const value = pvar();
+    if (!value || value === deps.packagesRootDir) {
+        return undefined;
+    }
+    return deps.resolvePath(value);
+}
+async function hasPackageJson(deps, localPath) {
+    return deps.fs.exists(deps.resolvePath(localPath, "package.json"));
+}
+function packageNameToFolderSlug(name) {
+    let slug = name.replace(/[^a-zA-Z0-9]/g, " ");
+    slug = slug.replace(/\s+/g, " ").trim();
+    return (0, utils_1.camelCaseToHyphens)(slug);
+}
+/**
+ * Resolve the local filesystem path for a package based on device vars.
+ * Awaits the loading promise to ensure the DB-stored value is available
+ * before reading. Falls back to paths from other data contexts on this device,
+ * then to `{packagesRootDir}/{name-slug}` when that directory exists.
+ */
+async function getPackageLocalPath(packageId, dataContext, deps) {
+    const candidates = [];
+    const currentPath = await readPackageLocalPathPvar(packageId, dataContext, deps);
+    if (currentPath) {
+        candidates.push(currentPath);
+    }
+    const userContext = dataContext.userContext;
+    if (userContext && dataContext.dataContextId !== userContext.userId) {
+        const personalPath = await readPackageLocalPathPvar(packageId, userContext.userDataContext, deps);
+        if (personalPath) {
+            candidates.push(personalPath);
+        }
+    }
+    if (userContext) {
+        for (const dc of userContext.groupDataContexts.values()) {
+            if (dc.dataContextId === dataContext.dataContextId)
+                continue;
+            const groupPath = await readPackageLocalPathPvar(packageId, dc, deps);
+            if (groupPath) {
+                candidates.push(groupPath);
+            }
+        }
+    }
+    const pkg = await (0, packages_1.Packages)(dataContext).get(packageId);
+    if (pkg) {
+        candidates.push(deps.resolvePath(deps.packagesRootDir, packageNameToFolderSlug(pkg.name)));
+    }
+    for (const path of candidates) {
+        if (await hasPackageJson(deps, path)) {
+            return path;
+        }
+    }
+    return candidates[0] ?? deps.packagesRootDir;
 }
 /** Extract the first non-heading paragraph from a README as a description. */
 function extractReadmeDescription(readme) {

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

@@ -658,9 +658,46 @@ describe("getPackageLocalPath (via installPackageFromBundles)", () => {
         const deps = makeMockDeps({});
         const dc = mockDataContext();
         mockGroupDeviceVar.mockReturnValue(Object.assign(() => undefined, { loadingPromise: Promise.resolve() }));
+        mockGetPkg.mockResolvedValue(undefined);
         // Since resolvePath just joins, and packagesRootDir = "/packages",
         // the resolved path will be "/packages" — which won't have bundles.
         // This should throw "Package directory does not exist"
         await expect((0, package_installer_1.installPackageFromBundles)(dc, deps, packageId, { skipLoad: true, skipResolve: true })).rejects.toThrow("Package directory does not exist");
     });
+    it("falls back to personal context packageLocalPath in another group context", async () => {
+        const packageId = (0, utils_1.newid)();
+        const personalPath = `/packages/my-widget`;
+        const files = {
+            [`${personalPath}/package.json`]: JSON.stringify({ name: "My Widget", version: "1.0.0" }),
+            [`${personalPath}/dist/package.bundle.js`]: "code",
+        };
+        const deps = makeMockDeps(files);
+        const personalDc = { dataContextId: "user123" };
+        const groupDc = mockDataContext({
+            dataContextId: "group456",
+            userContext: {
+                userId: "user123",
+                userDataContext: personalDc,
+                groupDataContexts: new Map([["group456", { dataContextId: "group456" }]]),
+            },
+        });
+        mockGroupDeviceVar.mockImplementation((_name, opts) => {
+            const path = opts?.dataContext?.dataContextId === "user123" ? personalPath : deps.packagesRootDir;
+            return Object.assign(() => path, { loadingPromise: Promise.resolve() });
+        });
+        mockFindOnePV.mockResolvedValue(undefined);
+        mockFindOneFile.mockResolvedValue(undefined);
+        mockGetPkg.mockResolvedValue({
+            packageId,
+            name: "My Widget",
+            description: "",
+            signature: "",
+            createdBy: "u",
+        });
+        await (0, package_installer_1.installPackageFromBundles)(groupDc, deps, packageId, {
+            skipLoad: true,
+            skipResolve: true,
+        });
+        expect(mockSignAndSavePV).toHaveBeenCalled();
+    });
 });

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

@@ -5,8 +5,13 @@
  * Called at group creation time (not on every startup).
  */
 import type { DataContext } from "../context/data-context";
-/** Options for seeding a package into a data context. */
-export interface ISeedPackageOpts {
+import { type IPackage } from "../data/packages";
+/**
+ * Metadata needed to create (or backfill) a {@link IPackage} record, without
+ * any version/bundle data. Shared by {@link ensurePackageRecord} and
+ * {@link seedPackageInContext}.
+ */
+export interface IEnsurePackageRecordOpts {
     packageId: string;
     name: string;
     description?: string;
@@ -16,6 +21,9 @@ export interface ISeedPackageOpts {
     followVersionTags?: string;
     updateUrl?: string;
     remoteRepo?: string;
+}
+/** Options for seeding a package into a data context. */
+export interface ISeedPackageOpts extends IEnsurePackageRecordOpts {
     /** Bundle data for the initial PackageVersion. */
     version: string;
     versionTag: string;
@@ -43,3 +51,11 @@ export interface ISeedPackageOpts {
  * @returns true if seeding occurred, false if package already existed.
  */
 export declare function seedPackageInContext(dataContext: DataContext, opts: ISeedPackageOpts): Promise<boolean>;
+/**
+ * Ensure a {@link IPackage} record exists in `dataContext`, creating it from
+ * `opts` when absent and backfilling any missing metadata defaults when
+ * present. Does not create or modify any PackageVersion.
+ *
+ * @returns The current (created or existing) Package record.
+ */
+export declare function ensurePackageRecord(dataContext: DataContext, opts: IEnsurePackageRecordOpts): Promise<IPackage>;

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

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.seedPackageInContext = seedPackageInContext;
+exports.ensurePackageRecord = ensurePackageRecord;
 const package_versions_1 = require("../data/package-versions");
 const packages_1 = require("../data/packages");
 const utils_1 = require("../utils");
@@ -21,20 +22,35 @@ const package_installer_1 = require("./package-installer");
  * @returns true if seeding occurred, false if package already existed.
  */
 async function seedPackageInContext(dataContext, opts) {
-    const pkgTable = (0, packages_1.Packages)(dataContext);
-    const existingPkg = await pkgTable.get(opts.packageId);
+    const existingPkg = await (0, packages_1.Packages)(dataContext).get(opts.packageId);
     if (existingPkg) {
         // Package already exists — check if it has any version installed
-        const pvTable = (0, package_versions_1.PackageVersions)(dataContext);
-        const existingPvs = await pvTable.list({ packageId: opts.packageId });
+        const existingPvs = await (0, package_versions_1.PackageVersions)(dataContext).list({ packageId: opts.packageId });
         if (existingPvs.length > 0) {
             return false;
         }
-        // Package record exists but no versions — install the initial PV
-        applyMissingSeedDefaults(existingPkg, opts);
-        return await installSeedVersion(dataContext, existingPkg, opts);
     }
-    // Create Package record with provided defaults
+    // Create the Package record (or backfill missing defaults on an existing one),
+    // then install the initial PackageVersion from the bundle.
+    const pkg = await ensurePackageRecord(dataContext, opts);
+    return await installSeedVersion(dataContext, pkg, opts);
+}
+/**
+ * Ensure a {@link IPackage} record exists in `dataContext`, creating it from
+ * `opts` when absent and backfilling any missing metadata defaults when
+ * present. Does not create or modify any PackageVersion.
+ *
+ * @returns The current (created or existing) Package record.
+ */
+async function ensurePackageRecord(dataContext, opts) {
+    const pkgTable = (0, packages_1.Packages)(dataContext);
+    const existing = await pkgTable.get(opts.packageId);
+    if (existing) {
+        if (applyMissingRecordDefaults(existing, opts)) {
+            return await pkgTable.signAndSave(existing, { saveAsSnapshot: true });
+        }
+        return existing;
+    }
     const pkg = {
         packageId: opts.packageId,
         name: opts.name,
@@ -48,17 +64,24 @@ async function seedPackageInContext(dataContext, opts) {
         remoteRepo: opts.remoteRepo,
         signature: "",
     };
-    await pkgTable.signAndSave(pkg, { saveAsSnapshot: true });
-    await installSeedVersion(dataContext, pkg, opts);
-    return true;
+    return pkgTable.signAndSave(pkg, { saveAsSnapshot: true });
 }
-function applyMissingSeedDefaults(pkg, opts) {
-    pkg.description ||= opts.description ?? "";
-    pkg.publishPublicKey ||= opts.publishPublicKey ?? "";
-    pkg.versionFollowRange ||= opts.versionFollowRange;
-    pkg.followVersionTags ||= opts.followVersionTags;
-    pkg.updateUrl ||= opts.updateUrl;
-    pkg.remoteRepo ||= opts.remoteRepo;
+/** Backfill missing metadata onto an existing record. Returns true if changed. */
+function applyMissingRecordDefaults(pkg, opts) {
+    let changed = false;
+    const setIfEmpty = (key, value) => {
+        if (!pkg[key] && value) {
+            pkg[key] = value;
+            changed = true;
+        }
+    };
+    setIfEmpty("description", opts.description);
+    setIfEmpty("publishPublicKey", opts.publishPublicKey);
+    setIfEmpty("versionFollowRange", opts.versionFollowRange);
+    setIfEmpty("followVersionTags", opts.followVersionTags);
+    setIfEmpty("updateUrl", opts.updateUrl);
+    setIfEmpty("remoteRepo", opts.remoteRepo);
+    return changed;
 }
 async function installSeedVersion(dataContext, pkg, opts) {
     // Save bundle files (deduped by hash)

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

@@ -0,0 +1,49 @@
+/**
+ * peers-core install orchestrator.
+ *
+ * Ensures the `peers-core` package is installed into a given data context using
+ * a layered strategy:
+ *
+ * 1. No-op if peers-core already has a version in the context.
+ * 2. Copy from another context that already has it (used for new groups).
+ * 3. Install from the remote S3 `updateUrl` (used for new users; group fallback).
+ * 4. Seed the bundled copy shipped with the host app (offline fallback).
+ *
+ * Callers shape the strategy by what they pass: new users provide no
+ * `copyFromContexts` (remote-first), while new groups pass sibling contexts so
+ * they copy first and fall back to the remote `updateUrl`.
+ */
+import type { DataContext } from "../context/data-context";
+import type { UserContext } from "../context/user-context";
+import type { IHttpDeps } from "./types";
+/** Bundled peers-core sources shipped with the host app (offline fallback). */
+export interface IPeersCoreBundle {
+    version: string;
+    versionTag: string;
+    packageBundleCode: string;
+    routesBundleCode?: string;
+    uiBundleCode?: string;
+}
+/** Options controlling {@link ensurePeersCore}'s install strategy. */
+export interface IEnsurePeersCoreOpts {
+    /** HTTP interface for remote install. Omit to disable the remote path. */
+    http?: IHttpDeps;
+    /** S3 `updateUrl` for peers-core. Required for the remote path. */
+    updateUrl?: string;
+    /** Contexts to copy an already-installed peers-core from (e.g. personal + other groups). */
+    copyFromContexts?: DataContext[];
+    /** Bundled sources used as the offline fallback. */
+    bundle?: IPeersCoreBundle;
+    /** When true, try the bundled seed before the remote install (dev electron). */
+    preferBundle?: boolean;
+    /** Version tag to follow for the remote install. Defaults to `"stable"`. */
+    followTag?: string;
+}
+/**
+ * Ensure peers-core is installed (with a usable, loaded version) in
+ * `dataContext`, applying the layered strategy described in the module docs.
+ *
+ * @returns true if an install occurred, false if it was already present or no
+ *   strategy succeeded.
+ */
+export declare function ensurePeersCore(userContext: UserContext, dataContext: DataContext, opts: IEnsurePeersCoreOpts): Promise<boolean>;

package/dist/package-installer/peers-core-installer.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * peers-core install orchestrator.
+ *
+ * Ensures the `peers-core` package is installed into a given data context using
+ * a layered strategy:
+ *
+ * 1. No-op if peers-core already has a version in the context.
+ * 2. Copy from another context that already has it (used for new groups).
+ * 3. Install from the remote S3 `updateUrl` (used for new users; group fallback).
+ * 4. Seed the bundled copy shipped with the host app (offline fallback).
+ *
+ * Callers shape the strategy by what they pass: new users provide no
+ * `copyFromContexts` (remote-first), while new groups pass sibling contexts so
+ * they copy first and fall back to the remote `updateUrl`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensurePeersCore = ensurePeersCore;
+const package_version_resolver_1 = require("../data/package-version-resolver");
+const package_versions_1 = require("../data/package-versions");
+const packages_1 = require("../data/packages");
+const packages_utils_1 = require("../data/packages.utils");
+const system_ids_1 = require("../system-ids");
+const package_remote_checker_1 = require("./package-remote-checker");
+const package_seed_installer_1 = require("./package-seed-installer");
+const PEERS_CORE_NAME = "peers-core";
+const PEERS_CORE_DESCRIPTION = "Core system package for Peers platform";
+/**
+ * Ensure peers-core is installed (with a usable, loaded version) in
+ * `dataContext`, applying the layered strategy described in the module docs.
+ *
+ * @returns true if an install occurred, false if it was already present or no
+ *   strategy succeeded.
+ */
+async function ensurePeersCore(userContext, dataContext, opts) {
+    const existingPvs = await (0, package_versions_1.PackageVersions)(dataContext).list({ packageId: system_ids_1.peersCorePackageId });
+    if (existingPvs.length > 0)
+        return false;
+    if (await tryCopyFromContexts(dataContext, opts.copyFromContexts)) {
+        return true;
+    }
+    const tryRemote = () => tryRemoteInstall(userContext, dataContext, opts);
+    const tryBundle = () => tryBundleSeed(userContext, dataContext, opts);
+    const strategies = opts.preferBundle ? [tryBundle, tryRemote] : [tryRemote, tryBundle];
+    for (const strategy of strategies) {
+        if (await strategy())
+            return true;
+    }
+    return false;
+}
+/** Copy peers-core from the first sibling context that already has it, then load it. */
+async function tryCopyFromContexts(dataContext, copyFromContexts) {
+    if (!copyFromContexts?.length)
+        return false;
+    for (const source of copyFromContexts) {
+        if (source.dataContextId === dataContext.dataContextId)
+            continue;
+        try {
+            const sourcePkg = await (0, packages_1.Packages)(source).get(system_ids_1.peersCorePackageId);
+            if (!sourcePkg?.activePackageVersionId)
+                continue;
+            await (0, packages_utils_1.copyPackageToAnotherDataContext)(system_ids_1.peersCorePackageId, source, dataContext);
+            const copied = await (0, packages_1.Packages)(dataContext).get(system_ids_1.peersCorePackageId);
+            if (copied) {
+                await (0, package_version_resolver_1.resolveDevicePackageVersion)(copied, dataContext, { force: true });
+            }
+            return true;
+        }
+        catch (err) {
+            console.warn(`[peers-core-installer] copy from ${source.dataContextId} failed:`, err);
+        }
+    }
+    return false;
+}
+/** Create the Package record (if needed) and install the latest remote version. */
+async function tryRemoteInstall(userContext, dataContext, opts) {
+    if (!opts.http || !opts.updateUrl)
+        return false;
+    try {
+        const pkg = await (0, package_seed_installer_1.ensurePackageRecord)(dataContext, {
+            packageId: system_ids_1.peersCorePackageId,
+            name: PEERS_CORE_NAME,
+            description: PEERS_CORE_DESCRIPTION,
+            createdBy: userContext.userId,
+            publishPublicKey: system_ids_1.peersCorePublishPublicKey,
+            versionFollowRange: "latest",
+            followVersionTags: "stable",
+            updateUrl: opts.updateUrl,
+            remoteRepo: system_ids_1.peersCorePackageRepoUrl,
+        });
+        const result = await (0, package_remote_checker_1.checkAndInstallPackageRemoteVersion)(dataContext, pkg, opts.followTag ?? "stable", opts.http);
+        return !!result;
+    }
+    catch (err) {
+        console.warn("[peers-core-installer] remote install failed:", err);
+        return false;
+    }
+}
+/** Seed the bundled peers-core sources as an offline fallback. */
+async function tryBundleSeed(userContext, dataContext, opts) {
+    if (!opts.bundle)
+        return false;
+    try {
+        return await (0, package_seed_installer_1.seedPackageInContext)(dataContext, {
+            packageId: system_ids_1.peersCorePackageId,
+            name: PEERS_CORE_NAME,
+            description: PEERS_CORE_DESCRIPTION,
+            createdBy: userContext.userId,
+            publishPublicKey: system_ids_1.peersCorePublishPublicKey,
+            versionFollowRange: "latest",
+            followVersionTags: "stable",
+            updateUrl: opts.updateUrl,
+            remoteRepo: system_ids_1.peersCorePackageRepoUrl,
+            version: opts.bundle.version,
+            versionTag: opts.bundle.versionTag,
+            packageBundleCode: opts.bundle.packageBundleCode,
+            routesBundleCode: opts.bundle.routesBundleCode,
+            uiBundleCode: opts.bundle.uiBundleCode,
+            loadAfterSeed: true,
+        });
+    }
+    catch (err) {
+        console.warn("[peers-core-installer] bundle seed failed:", err);
+        return false;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peers-app/peers-sdk",
-  "version": "0.19.9",
+  "version": "0.19.12",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/peers-app/peers-sdk.git"