@peers-app/peers-sdk 0.23.14 → 0.24.0

package/dist/invites/group-approval.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGroupApproval = buildGroupApproval;
+exports.importGroupApproval = importGroupApproval;
+const data_1 = require("../data");
+const keys_1 = require("../keys");
+const utils_1 = require("../utils");
+/**
+ * Builds the approval payload for a joiner: signs their membership row, gathers Admin+
+ * seed rows plus the approver's own Users/Devices records, and boxes the group secret to
+ * the joiner's box key.
+ *
+ * The approver must hold Admin+ in the group. The membership row is signed and saved in
+ * the approver's group context here; it syncs to the joiner when they connect and is also
+ * carried in the payload so the joiner can seed their copy immediately.
+ *
+ * @throws when the group is unknown, the approver is not Admin+, or the secret is unavailable
+ */
+async function buildGroupApproval(userContext, input) {
+    const group = await (0, data_1.Groups)(userContext.userDataContext).get(input.groupId);
+    if (!group) {
+        throw new Error("Group not found");
+    }
+    const groupDataContext = userContext.getDataContext(input.groupId);
+    const groupMembersTable = (0, data_1.GroupMembers)(groupDataContext);
+    let approvingMember = await groupMembersTable.findOne({
+        groupId: input.groupId,
+        userId: userContext.userId,
+    });
+    if (!approvingMember && group.founderUserId === userContext.userId) {
+        // Groups created before founders got an explicit membership row: the founder role is
+        // implicit (see `getUserRole`). Write the row now so it seeds to joiners like any admin.
+        approvingMember = await groupMembersTable.signAndSave({
+            groupMemberId: (0, utils_1.newid)(),
+            groupId: input.groupId,
+            userId: userContext.userId,
+            role: data_1.GroupMemberRole.Founder,
+            signature: "",
+        });
+    }
+    if (!approvingMember || approvingMember.deleted || approvingMember.role < data_1.GroupMemberRole.Admin) {
+        throw new Error("Only Admin or higher members can approve group joins");
+    }
+    if (input.role > approvingMember.role) {
+        throw new Error("Cannot grant a role higher than your own");
+    }
+    const groupSecretKey = await (0, data_1.readGroupSecretKey)(userContext, input.groupId, input.approverKeys.secretKey);
+    const joinerUser = {
+        userId: input.joiner.userId,
+        name: input.joiner.displayName || input.joiner.userId,
+        publicKey: input.joiner.publicKey,
+        publicBoxKey: input.joiner.publicBoxKey,
+    };
+    const saveOptions = { restoreIfDeleted: true, weakInsert: true };
+    await (0, data_1.Users)(userContext.userDataContext).save(joinerUser, saveOptions);
+    await (0, data_1.Users)(groupDataContext).save(joinerUser, saveOptions);
+    const existingMember = await groupMembersTable.findOne({
+        groupId: input.groupId,
+        userId: input.joiner.userId,
+    });
+    let membership;
+    if (existingMember) {
+        existingMember.role = input.role;
+        delete existingMember.deleted;
+        membership = await groupMembersTable.signAndSave(existingMember);
+    }
+    else {
+        membership = await groupMembersTable.signAndSave({
+            groupMemberId: (0, utils_1.newid)(),
+            groupId: input.groupId,
+            userId: input.joiner.userId,
+            role: input.role,
+            signature: "",
+        });
+    }
+    let adminMembers = await groupMembersTable.list({ deleted: { $ne: true }, role: { $gte: data_1.GroupMemberRole.Admin } }, { pageSize: 5, sortBy: ["-groupMemberId"] });
+    if (!adminMembers.some((member) => member.groupMemberId === approvingMember.groupMemberId)) {
+        adminMembers = [approvingMember, ...adminMembers];
+    }
+    const me = await (0, data_1.Users)(userContext.userDataContext).get(userContext.userId);
+    if (!me) {
+        throw new Error("My user object was not found in the DB. Is the user setup?");
+    }
+    const myDevice = await (0, data_1.Devices)(userContext.userDataContext).get(input.approverDeviceId);
+    const seedDevices = [
+        {
+            userId: me.userId,
+            deviceId: input.approverDeviceId,
+            publicKey: input.approverKeys.publicKey,
+            publicBoxKey: input.approverKeys.publicBoxKey,
+            ...(myDevice?.name ? { deviceName: myDevice.name } : {}),
+        },
+    ];
+    return {
+        kind: "group-approval",
+        ...(input.inviteNonce ? { inviteNonce: input.inviteNonce } : {}),
+        group,
+        membership,
+        seed: {
+            groupMembers: adminMembers,
+            users: [me],
+            devices: seedDevices,
+        },
+        approver: {
+            userId: me.userId,
+            publicKey: me.publicKey,
+            publicBoxKey: me.publicBoxKey,
+            displayName: me.name,
+        },
+        approverDeviceId: input.approverDeviceId,
+        boxedSecret: (0, keys_1.boxDataWithKeys)(groupSecretKey, input.joiner.publicBoxKey, input.approverKeys.secretKey),
+    };
+}
+/**
+ * Imports a {@link GroupApproval} on the joiner's device: records the group, seeds the group
+ * context with the signed rows, saves the approver as a contact, and stores the unboxed
+ * group secret in the personal context after validating it against the group's keys.
+ *
+ * Personal `Groups` is added only when missing so a local leave stays authoritative.
+ * `Devices` rows for the approver are left to the caller (device layer).
+ */
+async function importGroupApproval(userContext, approval, joinerKeys) {
+    if (approval.membership.userId !== userContext.userId) {
+        throw new Error("Group approval is for a different user");
+    }
+    if (approval.membership.groupId !== approval.group.groupId) {
+        throw new Error("Group approval membership does not match the group");
+    }
+    if (approval.boxedSecret.fromPublicKey !== approval.approver.publicBoxKey ||
+        !approval.seed.users.some((user) => user.userId === approval.approver.userId)) {
+        throw new Error("Group approval approver identity is inconsistent");
+    }
+    const groupSecretKey = (0, keys_1.openBoxWithSecretKey)(approval.boxedSecret, joinerKeys.secretKey);
+    if (typeof groupSecretKey !== "string") {
+        throw new Error("Group approval did not contain a usable group secret");
+    }
+    const { group } = approval;
+    const existingGroup = await (0, data_1.Groups)(userContext.userDataContext).get(group.groupId);
+    if (!existingGroup) {
+        await (0, data_1.Groups)(userContext.userDataContext).save(group, { restoreIfDeleted: true });
+    }
+    await (0, data_1.seedGroupContextFromShare)(userContext, { group, groupMembers: approval.seed.groupMembers }, [approval.membership]);
+    const groupDataContext = userContext.getDataContext(group.groupId);
+    const saveOptions = { restoreIfDeleted: true, weakInsert: true };
+    for (const user of approval.seed.users) {
+        await (0, data_1.Users)(userContext.userDataContext).save(user, saveOptions);
+        await (0, data_1.Users)(groupDataContext).save(user, saveOptions);
+    }
+    await (0, data_1.saveGroupSecretKey)(userContext.userDataContext, group.groupId, groupSecretKey, group);
+    return {
+        groupId: group.groupId,
+        approverUserId: approval.approver.userId,
+        approverDeviceId: approval.approverDeviceId,
+    };
+}

package/dist/invites/group-approval.test.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const SQLiteDB = require("better-sqlite3");
+const user_context_1 = require("../context/user-context");
+const devices_1 = require("../data/devices");
+const group_member_roles_1 = require("../data/group-member-roles");
+const group_members_1 = require("../data/group-members");
+const group_secret_1 = require("../data/group-secret");
+const groups_1 = require("../data/groups");
+const sql_data_source_1 = require("../data/orm/sql.data-source");
+const persistent_vars_1 = require("../data/persistent-vars");
+const users_1 = require("../data/users");
+const keys_1 = require("../keys");
+const rpc_types_1 = require("../rpc-types");
+const utils_1 = require("../utils");
+const group_approval_1 = require("./group-approval");
+const invite_messages_1 = require("./invite-messages");
+class DBHarness {
+    _db = null;
+    get db() {
+        if (!this._db) {
+            this._db = new SQLiteDB(":memory:");
+            this._db.pragma("journal_mode = WAL");
+        }
+        return this._db;
+    }
+    async get(sql, params = []) {
+        return this.db.prepare(sql).get(params);
+    }
+    async all(sql, params = []) {
+        return this.db.prepare(sql).all(params);
+    }
+    async exec(sql, params = []) {
+        const result = this.db.prepare(sql).run(params);
+        return { changes: result.changes };
+    }
+    async close() {
+        this._db?.close();
+        this._db = null;
+    }
+}
+/** One in-memory user with its own personal and group databases. */
+async function makeUser(name) {
+    const dbs = new Map();
+    const keys = (0, keys_1.newKeys)();
+    const userId = (0, utils_1.newid)();
+    const dataSourceFactory = (metaData, schema, groupId) => {
+        const key = groupId || userId;
+        let db = dbs.get(key);
+        if (!db) {
+            db = new DBHarness();
+            dbs.set(key, db);
+        }
+        return new sql_data_source_1.SQLDataSource(db, metaData, schema);
+    };
+    const userContext = new user_context_1.UserContext(userId, dataSourceFactory, true);
+    await userContext.loadingPromise;
+    const deviceId = (0, utils_1.newid)();
+    userContext.deviceId(deviceId);
+    await (0, users_1.Users)(userContext.userDataContext).save({
+        userId,
+        name,
+        publicKey: keys.publicKey,
+        publicBoxKey: keys.publicBoxKey,
+    });
+    return {
+        userId,
+        deviceId,
+        keys,
+        userContext,
+        dispose: async () => {
+            userContext.dispose();
+            await Promise.all([...dbs.values()].map((db) => db.close()));
+        },
+    };
+}
+describe("group approval payloads", () => {
+    let admin;
+    let joiner;
+    let group;
+    let groupKeys;
+    const originalEncrypt = rpc_types_1.rpcServerCalls.encryptData;
+    beforeAll(async () => {
+        groups_1.GroupsTable.isPassthrough = true;
+        group_members_1.GroupMembersTable.isPassthrough = true;
+        users_1.UsersTable.isPassthrough = true;
+        admin = await makeUser("Alice");
+        joiner = await makeUser("Bob");
+        group_members_1.GroupMembersTable.enableGroupMemberSigning((member) => (0, keys_1.addSignatureToObject)(member, admin.keys.secretKey));
+        groupKeys = (0, keys_1.newKeys)();
+        group = {
+            groupId: (0, utils_1.newid)(),
+            name: "Family",
+            description: "",
+            founderUserId: admin.userId,
+            signature: "group-sig",
+            publicKey: groupKeys.publicKey,
+            publicBoxKey: groupKeys.publicBoxKey,
+        };
+        await (0, groups_1.Groups)(admin.userContext.userDataContext).save(group);
+        await (0, group_members_1.GroupMembers)(admin.userContext.getDataContext(group.groupId)).signAndSave({
+            groupMemberId: (0, utils_1.newid)(),
+            groupId: group.groupId,
+            userId: admin.userId,
+            role: group_member_roles_1.GroupMemberRole.Owner,
+            signature: "",
+        });
+        // The secret pvar is stored encrypted with the owning user's secret key.
+        await (0, persistent_vars_1.PersistentVars)(admin.userContext.userDataContext).save({
+            persistentVarId: "",
+            name: (0, group_secret_1.groupSecretKeyPvarName)(group.groupId),
+            scope: "groupUser",
+            isSecret: false,
+            value: { value: (0, keys_1.encryptData)(groupKeys.secretKey, admin.keys.secretKey) },
+        });
+        await (0, devices_1.Devices)(admin.userContext.userDataContext).save({
+            deviceId: admin.deviceId,
+            userId: admin.userId,
+            name: "Alice laptop",
+            firstSeen: new Date(),
+            lastSeen: new Date(),
+            trustLevel: 100,
+        });
+    });
+    afterAll(async () => {
+        groups_1.GroupsTable.isPassthrough = false;
+        group_members_1.GroupMembersTable.isPassthrough = false;
+        users_1.UsersTable.isPassthrough = false;
+        rpc_types_1.rpcServerCalls.encryptData = originalEncrypt;
+        await admin.dispose();
+        await joiner.dispose();
+    });
+    it("builds an approval the joiner can import, including the boxed group secret", async () => {
+        const approval = await (0, group_approval_1.buildGroupApproval)(admin.userContext, {
+            groupId: group.groupId,
+            joiner: {
+                userId: joiner.userId,
+                publicKey: joiner.keys.publicKey,
+                publicBoxKey: joiner.keys.publicBoxKey,
+                displayName: "Bob",
+            },
+            role: group_member_roles_1.GroupMemberRole.Writer,
+            approverKeys: admin.keys,
+            approverDeviceId: admin.deviceId,
+        });
+        expect(() => invite_messages_1.groupApprovalSchema.parse(approval)).not.toThrow();
+        expect(approval.membership).toMatchObject({
+            userId: joiner.userId,
+            role: group_member_roles_1.GroupMemberRole.Writer,
+        });
+        expect(approval.membership.signature).toContain(":");
+        expect(approval.seed.groupMembers.map((member) => member.userId)).toContain(admin.userId);
+        expect(approval.seed.devices[0]).toMatchObject({
+            deviceId: admin.deviceId,
+            deviceName: "Alice laptop",
+        });
+        expect(JSON.stringify(approval)).not.toContain(groupKeys.secretKey);
+        // The joiner side re-encrypts the secret with its own key when saving the pvar.
+        rpc_types_1.rpcServerCalls.encryptData = async (value) => (0, keys_1.encryptData)(value, joiner.keys.secretKey);
+        const result = await (0, group_approval_1.importGroupApproval)(joiner.userContext, approval, joiner.keys);
+        expect(result).toEqual({
+            groupId: group.groupId,
+            approverUserId: admin.userId,
+            approverDeviceId: admin.deviceId,
+        });
+        await expect((0, groups_1.Groups)(joiner.userContext.userDataContext).get(group.groupId)).resolves.toMatchObject({ name: "Family" });
+        const joinerGroupContext = joiner.userContext.getDataContext(group.groupId);
+        await expect((0, group_members_1.GroupMembers)(joinerGroupContext).findOne({ userId: joiner.userId, groupId: group.groupId })).resolves.toMatchObject({ role: group_member_roles_1.GroupMemberRole.Writer });
+        await expect((0, group_members_1.GroupMembers)(joinerGroupContext).findOne({ userId: admin.userId, groupId: group.groupId })).resolves.toMatchObject({ role: group_member_roles_1.GroupMemberRole.Owner });
+        await expect((0, users_1.Users)(joiner.userContext.userDataContext).get(admin.userId)).resolves.toMatchObject({ name: "Alice" });
+        await expect((0, group_secret_1.readGroupSecretKey)(joiner.userContext, group.groupId, joiner.keys.secretKey)).resolves.toBe(groupKeys.secretKey);
+    });
+    it("rejects approvals addressed to someone else or with a mismatched box sender", async () => {
+        const approval = await (0, group_approval_1.buildGroupApproval)(admin.userContext, {
+            groupId: group.groupId,
+            joiner: {
+                userId: joiner.userId,
+                publicKey: joiner.keys.publicKey,
+                publicBoxKey: joiner.keys.publicBoxKey,
+            },
+            role: group_member_roles_1.GroupMemberRole.Reader,
+            approverKeys: admin.keys,
+            approverDeviceId: admin.deviceId,
+        });
+        const stranger = await makeUser("Carol");
+        try {
+            await expect((0, group_approval_1.importGroupApproval)(stranger.userContext, approval, stranger.keys)).rejects.toThrow("different user");
+        }
+        finally {
+            await stranger.dispose();
+        }
+        await expect((0, group_approval_1.importGroupApproval)(joiner.userContext, {
+            ...approval,
+            boxedSecret: { ...approval.boxedSecret, fromPublicKey: (0, keys_1.newKeys)().publicBoxKey },
+        }, joiner.keys)).rejects.toThrow("inconsistent");
+    });
+    it("refuses to approve from a non-admin or to grant above the approver's role", async () => {
+        await expect((0, group_approval_1.buildGroupApproval)(joiner.userContext, {
+            groupId: group.groupId,
+            joiner: {
+                userId: (0, utils_1.newid)(),
+                publicKey: (0, keys_1.newKeys)().publicKey,
+                publicBoxKey: (0, keys_1.newKeys)().publicBoxKey,
+            },
+            role: group_member_roles_1.GroupMemberRole.Reader,
+            approverKeys: joiner.keys,
+            approverDeviceId: joiner.deviceId,
+        })).rejects.toThrow();
+        await expect((0, group_approval_1.buildGroupApproval)(admin.userContext, {
+            groupId: group.groupId,
+            joiner: {
+                userId: (0, utils_1.newid)(),
+                publicKey: (0, keys_1.newKeys)().publicKey,
+                publicBoxKey: (0, keys_1.newKeys)().publicBoxKey,
+            },
+            role: group_member_roles_1.GroupMemberRole.Founder,
+            approverKeys: admin.keys,
+            approverDeviceId: admin.deviceId,
+        })).rejects.toThrow("higher than your own");
+    });
+});

package/dist/invites/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./data-box-schema";
+export * from "./group-approval";
+export * from "./invite-epoch";
+export * from "./invite-messages";
+export * from "./invite-token";

package/dist/{group-invite → invites}/index.js

@@ -14,6 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./group-invite"), exports);
-__exportStar(require("./group-invite.pvars"), exports);
-__exportStar(require("./group-invite.types"), exports);
+__exportStar(require("./data-box-schema"), exports);
+__exportStar(require("./group-approval"), exports);
+__exportStar(require("./invite-epoch"), exports);
+__exportStar(require("./invite-messages"), exports);
+__exportStar(require("./invite-token"), exports);

package/dist/invites/invite-epoch.d.ts

@@ -0,0 +1,18 @@
+import type { UserContext } from "../context/user-context";
+import { type PersistentVar } from "../data/persistent-vars";
+/** Name of the synced personal-context variable that holds the invite epoch. */
+export declare const INVITE_EPOCH_VAR_NAME = "inviteEpoch";
+/**
+ * The user's current invite epoch, synced across their devices.
+ *
+ * Every issued token records the epoch at issue time. Bumping the epoch revokes every
+ * outstanding token at once (including the profile QR); devices ignore replies and join
+ * requests whose token epoch is older than the inviter's current epoch.
+ *
+ * @param userContext - Bind to a specific user context; defaults to the process singleton.
+ */
+export declare function inviteEpochVar(userContext?: UserContext): PersistentVar<number>;
+/** Increments the invite epoch, revoking all outstanding tokens; returns the new epoch. */
+export declare function bumpInviteEpoch(userContext?: UserContext): Promise<number>;
+/** Returns the current epoch after the variable has loaded. */
+export declare function currentInviteEpoch(userContext?: UserContext): Promise<number>;

package/dist/invites/invite-epoch.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVITE_EPOCH_VAR_NAME = void 0;
+exports.inviteEpochVar = inviteEpochVar;
+exports.bumpInviteEpoch = bumpInviteEpoch;
+exports.currentInviteEpoch = currentInviteEpoch;
+const persistent_vars_1 = require("../data/persistent-vars");
+/** Name of the synced personal-context variable that holds the invite epoch. */
+exports.INVITE_EPOCH_VAR_NAME = "inviteEpoch";
+/**
+ * The user's current invite epoch, synced across their devices.
+ *
+ * Every issued token records the epoch at issue time. Bumping the epoch revokes every
+ * outstanding token at once (including the profile QR); devices ignore replies and join
+ * requests whose token epoch is older than the inviter's current epoch.
+ *
+ * @param userContext - Bind to a specific user context; defaults to the process singleton.
+ */
+function inviteEpochVar(userContext) {
+    return (0, persistent_vars_1.userVar)(exports.INVITE_EPOCH_VAR_NAME, { defaultValue: 0, userContext });
+}
+/** Increments the invite epoch, revoking all outstanding tokens; returns the new epoch. */
+async function bumpInviteEpoch(userContext) {
+    const epoch = inviteEpochVar(userContext);
+    await epoch.loadingPromise;
+    const next = (epoch() ?? 0) + 1;
+    epoch(next);
+    return next;
+}
+/** Returns the current epoch after the variable has loaded. */
+async function currentInviteEpoch(userContext) {
+    const epoch = inviteEpochVar(userContext);
+    await epoch.loadingPromise;
+    return epoch() ?? 0;
+}