@peers-app/peers-sdk 0.20.6 → 0.21.1

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

@@ -47,7 +47,7 @@ export interface IInstallOpts {
     localPath?: string;
     /** Version tag for the created PackageVersion. Defaults to `"dev"`. */
     versionTag?: string;
-    /** Skip `packageLoader.loadPackage` (useful for batch installs). */
+    /** Skip keeping the package in the loader cache for activation. AppNavs are still backfilled when missing. */
     skipLoad?: boolean;
     /** Skip `resolveDevicePackageVersion` after install. */
     skipResolve?: boolean;

package/dist/package-loader/package-loader.d.ts

@@ -23,9 +23,9 @@ export declare class PackageLoader {
     private _readLocalBundle;
     /**
      * Post-correction: if the package definition carries a version string,
-     * update the active IPackageVersion record to match. This fixes cases where
-     * the PV record was created with stale or placeholder values (e.g. "0.0.1")
-     * before the bundle was evaluated.
+     * update the active IPackageVersion record to match — but only when that
+     * active version is the mutable `dev` working copy. Never rewrite
+     * beta/stable version labels from a local package.json bump.
      */
     private correctPackageVersion;
     private _evaluateBundle;

package/dist/package-loader/package-loader.js

@@ -104,9 +104,9 @@ class PackageLoader {
     }
     /**
      * Post-correction: if the package definition carries a version string,
-     * update the active IPackageVersion record to match. This fixes cases where
-     * the PV record was created with stale or placeholder values (e.g. "0.0.1")
-     * before the bundle was evaluated.
+     * update the active IPackageVersion record to match — but only when that
+     * active version is the mutable `dev` working copy. Never rewrite
+     * beta/stable version labels from a local package.json bump.
      */
     correctPackageVersion(pkg, def) {
         if (!pkg.activePackageVersionId)
@@ -119,8 +119,18 @@ class PackageLoader {
             .then((pv) => {
             if (!pv)
                 return;
+            if (pv.versionTag !== "dev")
+                return;
             if (def.version && pv.version !== def.version) {
-                return pvTable.signAndSave({ ...pv, version: def.version });
+                const packageVersionHash = (0, package_versions_1.computePackageVersionHash)(def.version, pv.versionTag || "dev", pv.packageBundleFileHash, pv.routesBundleFileHash, pv.uiBundleFileHash);
+                // Version is part of both the content hash and the author-signed
+                // payload — clear any prior author signature so it cannot go stale.
+                const { packageAuthorSignature: _staleSig, ...rest } = pv;
+                return pvTable.signAndSave({
+                    ...rest,
+                    version: def.version,
+                    packageVersionHash,
+                });
             }
         })
             .catch((err) => {

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

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

package/dist/package-loader/package-loader.test.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mockGet = jest.fn();
+const mockSignAndSave = jest.fn();
+const mockComputePackageVersionHash = jest.fn((version, _tag, packageBundleFileHash, _routesBundleFileHash, _uiBundleFileHash) => `hash-${version}-${packageBundleFileHash}`);
+jest.mock("../data/package-versions", () => ({
+    PackageVersions: () => ({
+        get: (...args) => mockGet(...args),
+        signAndSave: (...args) => mockSignAndSave(...args),
+    }),
+    computePackageVersionHash: (version, versionTag, packageBundleFileHash, routesBundleFileHash, uiBundleFileHash) => mockComputePackageVersionHash(version, versionTag, packageBundleFileHash, routesBundleFileHash, uiBundleFileHash),
+}));
+const package_loader_1 = require("./package-loader");
+describe("PackageLoader.correctPackageVersion", () => {
+    const activePvId = "pv-active";
+    const pkg = {
+        packageId: "pkg-1",
+        name: "Test Package",
+        activePackageVersionId: activePvId,
+    };
+    const def = { version: "0.3.6" };
+    let loader;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockSignAndSave.mockResolvedValue(undefined);
+        loader = new package_loader_1.PackageLoader({ dataContextId: "ctx" });
+    });
+    async function correctPackageVersion() {
+        loader.correctPackageVersion(pkg, def);
+        // Flush the fire-and-forget promise chain
+        await new Promise((r) => setImmediate(r));
+    }
+    it("updates the active PV hash and clears a stale author signature", async () => {
+        mockGet.mockResolvedValue({
+            packageVersionId: activePvId,
+            version: "0.3.1",
+            versionTag: "dev",
+            packageBundleFileHash: "bundle-hash",
+            routesBundleFileHash: "routes-hash",
+            uiBundleFileHash: "ui-hash",
+            packageAuthorSignature: "stale-sig",
+            packageVersionHash: "old-hash",
+        });
+        await correctPackageVersion();
+        expect(mockComputePackageVersionHash).toHaveBeenCalledWith("0.3.6", "dev", "bundle-hash", "routes-hash", "ui-hash");
+        expect(mockSignAndSave).toHaveBeenCalledWith(expect.objectContaining({
+            packageVersionId: activePvId,
+            version: "0.3.6",
+            versionTag: "dev",
+            packageVersionHash: "hash-0.3.6-bundle-hash",
+        }));
+        expect(mockSignAndSave.mock.calls[0][0].packageAuthorSignature).toBeUndefined();
+    });
+    it("does not update the active PV when it is stable", async () => {
+        mockGet.mockResolvedValue({
+            packageVersionId: activePvId,
+            version: "0.3.5",
+            versionTag: "stable",
+        });
+        await correctPackageVersion();
+        expect(mockSignAndSave).not.toHaveBeenCalled();
+    });
+    it("does not update the active PV when it is beta", async () => {
+        mockGet.mockResolvedValue({
+            packageVersionId: activePvId,
+            version: "0.3.5",
+            versionTag: "beta",
+        });
+        await correctPackageVersion();
+        expect(mockSignAndSave).not.toHaveBeenCalled();
+    });
+    it("does nothing when the active PV version already matches", async () => {
+        mockGet.mockResolvedValue({
+            packageVersionId: activePvId,
+            version: "0.3.6",
+            versionTag: "dev",
+        });
+        await correctPackageVersion();
+        expect(mockSignAndSave).not.toHaveBeenCalled();
+    });
+});

package/dist/rpc-types.d.ts

@@ -1,6 +1,8 @@
 import type { IDeviceDatabaseQueryResult, IDeviceOperationStatus, IDeviceToolRunInput } from "./contracts/system/device-operations-contract";
 import type { ITool } from "./data/tools";
+import type { DevicePairingCeremonyAction, DevicePairingStartDestinationInput, DevicePairingStartSourceResult, DevicePairingState } from "./device-pairing";
 import type { IConsoleLog } from "./logging/console-logs.table";
+import type { IAppNav } from "./types/app-nav";
 /** Named event payload sent across the frontend RPC bridge. */
 export interface IEventData<T = any> {
     name: string;
@@ -63,6 +65,13 @@ export declare const rpcServerCalls: {
     seedBundledPeersCore: (dataContextId?: string) => Promise<boolean>;
     setUserIdAndSecretKey: (userId: string, secretKey: string) => Promise<void>;
     getUserId: () => Promise<string | undefined>;
+    devicePairingStartSource: () => Promise<DevicePairingStartSourceResult>;
+    devicePairingStartDestination: (input: DevicePairingStartDestinationInput) => Promise<DevicePairingState>;
+    devicePairingApprove: (input: DevicePairingCeremonyAction) => Promise<DevicePairingState>;
+    devicePairingReject: (input: DevicePairingCeremonyAction) => Promise<DevicePairingState>;
+    devicePairingCancel: (input: DevicePairingCeremonyAction) => Promise<DevicePairingState>;
+    devicePairingGetState: () => Promise<DevicePairingState>;
+    devicePairingGetInvitationUrl: () => Promise<string | undefined>;
     encryptData: (value: string, groupId?: string) => Promise<string>;
     /**
      * Decrypt (if secret) and copy a persistent variable's value to the system clipboard
@@ -107,6 +116,8 @@ export declare const rpcServerCalls: {
     /**
      * Sign a package version with the package author's key (server-side only — key never leaves the server).
      * Returns the base64url detached signature, or undefined if the signing key isn't available.
+     * Optional fields (appNavs, createdBy, createdAt) must match the PV record when present so
+     * propagation verification of the full record succeeds.
      */
     signPackageAuthorVersion: (pvFields: {
         packageId: string;
@@ -116,6 +127,9 @@ export declare const rpcServerCalls: {
         packageBundleFileHash: string;
         routesBundleFileHash?: string;
         uiBundleFileHash?: string;
+        appNavs?: IAppNav[];
+        createdBy?: string;
+        createdAt?: string;
     }) => Promise<string | undefined>;
     registerWithPeersServices: () => Promise<string>;
     appQuit: () => Promise<void>;

package/dist/rpc-types.js

@@ -21,6 +21,13 @@ exports.rpcServerCalls = {
     seedBundledPeersCore: rpcStub("seedBundledPeersCore"),
     setUserIdAndSecretKey: rpcStub("setUserIdAndSecretKey"),
     getUserId: rpcStub("getUserId"),
+    devicePairingStartSource: rpcStub("devicePairingStartSource"),
+    devicePairingStartDestination: rpcStub("devicePairingStartDestination"),
+    devicePairingApprove: rpcStub("devicePairingApprove"),
+    devicePairingReject: rpcStub("devicePairingReject"),
+    devicePairingCancel: rpcStub("devicePairingCancel"),
+    devicePairingGetState: rpcStub("devicePairingGetState"),
+    devicePairingGetInvitationUrl: rpcStub("devicePairingGetInvitationUrl"),
     encryptData: rpcStub("encryptData"),
     /**
      * Decrypt (if secret) and copy a persistent variable's value to the system clipboard
@@ -51,6 +58,8 @@ exports.rpcServerCalls = {
     /**
      * Sign a package version with the package author's key (server-side only — key never leaves the server).
      * Returns the base64url detached signature, or undefined if the signing key isn't available.
+     * Optional fields (appNavs, createdBy, createdAt) must match the PV record when present so
+     * propagation verification of the full record succeeds.
      */
     signPackageAuthorVersion: rpcStub("signPackageAuthorVersion"),
     registerWithPeersServices: rpcStub("registerWithPeersServices"),

package/package.json

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