@peers-app/peers-sdk 0.27.3 → 0.27.5

package/dist/data/sync-recovery-queue.test.js

@@ -1,215 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const sync_recovery_queue_1 = require("./sync-recovery-queue");
-const SQLiteDB = require("better-sqlite3");
-class DBHarness {
-    sqlite = new SQLiteDB(":memory:");
-    async get(sql, params = []) {
-        return this.sqlite.prepare(sql).get(params);
-    }
-    async all(sql, params = []) {
-        return this.sqlite.prepare(sql).all(params);
-    }
-    async exec(sql, params = []) {
-        const result = this.sqlite.prepare(sql).run(params);
-        return { changes: result.changes };
-    }
-    getSync(sql, params = []) {
-        return this.sqlite.prepare(sql).get(params);
-    }
-    allSync(sql, params = []) {
-        return this.sqlite.prepare(sql).all(params);
-    }
-    execSync(sql, params = []) {
-        const result = this.sqlite.prepare(sql).run(params);
-        return { changes: result.changes };
-    }
-    runInTransaction(fn) {
-        return this.sqlite.transaction(fn)();
-    }
-    async close() {
-        this.sqlite.close();
-    }
-}
-describe("SyncRecoveryQueueTable", () => {
-    let db;
-    let queue;
-    beforeEach(() => {
-        db = new DBHarness();
-        queue = (0, sync_recovery_queue_1.syncRecoveryQueueTable)(db);
-    });
-    afterEach(async () => {
-        await db.close();
-    });
-    it("returns one queue instance per database", async () => {
-        const otherDb = new DBHarness();
-        try {
-            expect((0, sync_recovery_queue_1.syncRecoveryQueueTable)(db)).toBe(queue);
-            expect((0, sync_recovery_queue_1.syncRecoveryQueueTable)(otherDb)).toBe((0, sync_recovery_queue_1.syncRecoveryQueueTable)(otherDb));
-            expect((0, sync_recovery_queue_1.syncRecoveryQueueTable)(otherDb)).not.toBe(queue);
-        }
-        finally {
-            await otherDb.close();
-        }
-    });
-    it("upserts failures for a record while preserving its queue identity", async () => {
-        await queue.recordFailure({
-            tableName: "Notes",
-            recordId: "note-1",
-            error: new Error("first failure"),
-            sourceDeviceId: "device-1",
-        });
-        const first = await queue.findOne({ tableName: "Notes", recordId: "note-1" });
-        await queue.recordFailure({
-            tableName: "Notes",
-            recordId: "note-1",
-            error: "second failure",
-            sourceDeviceId: "device-2",
-        });
-        const updated = await queue.findOne({ tableName: "Notes", recordId: "note-1" });
-        expect(first).toBeDefined();
-        expect(updated).toMatchObject({
-            syncRecoveryId: first?.syncRecoveryId,
-            tableName: "Notes",
-            recordId: "note-1",
-            firstFailedAt: first?.firstFailedAt,
-            attemptCount: 2,
-            failures: [
-                expect.objectContaining({ error: "first failure", sourceDeviceId: "device-1" }),
-                expect.objectContaining({ error: "second failure", sourceDeviceId: "device-2" }),
-            ],
-        });
-        if (!updated)
-            throw new Error("Expected an updated recovery entry");
-        expect(updated.lastFailedAt).toBeGreaterThanOrEqual(updated.firstFailedAt);
-        await expect(queue.count()).resolves.toBe(1);
-    });
-    it("bounds failure history and stored error length", async () => {
-        for (let attempt = 1; attempt <= 12; attempt++) {
-            await queue.recordFailure({
-                tableName: "Notes",
-                recordId: "note-1",
-                error: attempt === 12 ? "x".repeat(2_000) : `failure-${attempt}`,
-            });
-        }
-        const entry = await queue.findOne({ tableName: "Notes", recordId: "note-1" });
-        expect(entry?.attemptCount).toBe(12);
-        expect(entry?.failures).toHaveLength(10);
-        expect(entry?.failures[0].error).toBe("failure-3");
-        expect(entry?.failures.at(-1)?.error).toHaveLength(1_000);
-    });
-    it("supports asynchronous databases without transaction methods", async () => {
-        const asyncOnlyDb = {
-            get: db.get.bind(db),
-            all: db.all.bind(db),
-            exec: db.exec.bind(db),
-            close: async () => { },
-        };
-        const asyncQueue = new sync_recovery_queue_1.SyncRecoveryQueueTable({ db: asyncOnlyDb });
-        await asyncQueue.recordFailure({
-            tableName: "Notes",
-            recordId: "note-1",
-            error: new Error("first"),
-        });
-        await asyncQueue.recordFailure({
-            tableName: "Notes",
-            recordId: "note-1",
-            error: new Error("second"),
-        });
-        expect(await asyncQueue.findOne({ tableName: "Notes", recordId: "note-1" })).toMatchObject({
-            attemptCount: 2,
-        });
-        await asyncQueue.clearRecord("Notes", "note-1");
-        await expect(asyncQueue.count()).resolves.toBe(0);
-    });
-    it("rolls back synchronous queue clearing with its surrounding transaction", async () => {
-        await queue.recordFailure({
-            tableName: "Notes",
-            recordId: "note-1",
-            error: new Error("materialization failed"),
-        });
-        expect(() => db.runInTransaction(() => {
-            queue.clearRecordSync("Notes", "note-1");
-            throw new Error("rollback");
-        })).toThrow("rollback");
-        await expect(queue.count()).resolves.toBe(1);
-        db.runInTransaction(() => queue.clearRecordSync("Notes", "note-1"));
-        await expect(queue.count()).resolves.toBe(0);
-    });
-    it("parks, unparks, and schedules the next attempt without dropping the entry", async () => {
-        await queue.recordFailure({
-            tableName: "Notes",
-            recordId: "note-1",
-            error: new Error("Validation on insert failed"),
-        });
-        await queue.park("Notes", "note-1", "schema");
-        await queue.park("Notes", "note-1", "schema");
-        const parked = await queue.findOne({ tableName: "Notes", recordId: "note-1" });
-        expect(parked?.parkedReason).toBe("schema");
-        expect(parked?.parkedAt).toEqual(expect.any(Number));
-        await queue.recordFailure({
-            tableName: "Notes",
-            recordId: "note-1",
-            error: new Error("Validation on insert failed again"),
-        });
-        const afterFailure = await queue.findOne({ tableName: "Notes", recordId: "note-1" });
-        expect(afterFailure).toMatchObject({
-            parkedReason: "schema",
-            parkedAt: parked?.parkedAt,
-            attemptCount: 2,
-        });
-        await queue.setNextAttempt("Notes", "note-1", 50);
-        await queue.unpark("Notes", "note-1");
-        const unparked = await queue.findOne({ tableName: "Notes", recordId: "note-1" });
-        expect(unparked?.parkedAt).toBeUndefined();
-        expect(unparked?.parkedReason).toBeUndefined();
-        expect(unparked?.nextAttemptAt).toBeUndefined();
-        await expect(queue.count()).resolves.toBe(1);
-    });
-    it("keeps attempt history when a failure is recorded during park", async () => {
-        await queue.recordFailure({
-            tableName: "Notes",
-            recordId: "note-1",
-            error: new Error("first"),
-        });
-        const originalExecSync = db.execSync.bind(db);
-        let injected = false;
-        db.execSync = (sql, params) => {
-            if (!injected && String(sql).includes("COALESCE(parkedAt")) {
-                injected = true;
-                queue.recordFailureSync({
-                    tableName: "Notes",
-                    recordId: "note-1",
-                    error: new Error("second"),
-                });
-            }
-            return originalExecSync(sql, params);
-        };
-        await queue.park("Notes", "note-1", "schema");
-        const entry = await queue.findOne({ tableName: "Notes", recordId: "note-1" });
-        expect(entry?.attemptCount).toBe(2);
-        expect(entry?.failures.map((failure) => failure.error)).toEqual(["first", "second"]);
-        expect(entry?.parkedReason).toBe("schema");
-        expect(entry?.parkedAt).toEqual(expect.any(Number));
-        db.execSync = originalExecSync;
-    });
-    it("reports the earliest future stuck transition", () => {
-        const now = 1_000_000;
-        const due = now - sync_recovery_queue_1.SYNC_RECOVERY_STUCK_AGE_MS + 5_000;
-        expect((0, sync_recovery_queue_1.nextStuckSyncRecoveryAt)([
-            {
-                parkedAt: now,
-                attemptCount: sync_recovery_queue_1.SYNC_RECOVERY_STUCK_ATTEMPTS,
-                firstFailedAt: now - sync_recovery_queue_1.SYNC_RECOVERY_STUCK_AGE_MS,
-            },
-            {
-                attemptCount: sync_recovery_queue_1.SYNC_RECOVERY_STUCK_ATTEMPTS - 1,
-                firstFailedAt: now - sync_recovery_queue_1.SYNC_RECOVERY_STUCK_AGE_MS,
-            },
-            {
-                attemptCount: sync_recovery_queue_1.SYNC_RECOVERY_STUCK_ATTEMPTS,
-                firstFailedAt: due,
-            },
-        ], now)).toBe(due + sync_recovery_queue_1.SYNC_RECOVERY_STUCK_AGE_MS);
-    });
-});

package/dist/data/table-signing.test.d.ts

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

package/dist/data/table-signing.test.js

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tableNames = ["package-version", "package", "group", "group-member", "user"];
-// These key strings are the contract between installed SDK versions; do not rename them.
-const signingKey = (name) => Symbol.for(`@peers-app/peers-sdk/${name}-signing`);
-// Restore process-global registrations so these tests never leave test signers installed.
-const priorSigners = tableNames.map((name) => {
-    const key = signingKey(name);
-    return { key, descriptor: Object.getOwnPropertyDescriptor(globalThis, key) };
-});
-beforeEach(() => {
-    for (const { key } of priorSigners) {
-        Reflect.deleteProperty(globalThis, key);
-    }
-});
-afterEach(() => {
-    for (const { key, descriptor } of priorSigners) {
-        if (descriptor) {
-            Object.defineProperty(globalThis, key, descriptor);
-        }
-        else {
-            Reflect.deleteProperty(globalThis, key);
-        }
-    }
-});
-function loadSigningTables() {
-    let tables;
-    jest.isolateModules(() => {
-        const { PackageVersionsTable } = require("./package-versions");
-        const { PackagesTable } = require("./packages");
-        const { GroupsTable } = require("./groups");
-        const { GroupMembersTable } = require("./group-members");
-        const { UsersTable } = require("./users");
-        tables = {
-            "package-version": {
-                prototype: PackageVersionsTable.prototype,
-                enable: PackageVersionsTable.enablePackageVersionSigning,
-            },
-            package: { prototype: PackagesTable.prototype, enable: PackagesTable.enablePackageSigning },
-            group: { prototype: GroupsTable.prototype, enable: GroupsTable.enableGroupSigning },
-            "group-member": {
-                prototype: GroupMembersTable.prototype,
-                enable: GroupMembersTable.enableGroupMemberSigning,
-            },
-            user: { prototype: UsersTable.prototype, enable: UsersTable.enableUserSigning },
-        };
-    });
-    return tables;
-}
-describe("table signing across SDK module instances", () => {
-    it.each(tableNames)("shares and replaces the %s signer across copies", async (name) => {
-        const first = loadSigningTables()[name];
-        const second = loadSigningTables()[name];
-        expect(first.prototype).not.toBe(second.prototype);
-        // Stub persistence only: exercise the real signAndSave and registration methods.
-        const receiver = { save: jest.fn(async (record) => record) };
-        const row = { name: "Example", signature: "" };
-        const opts = { saveAsSnapshot: false };
-        await expect(second.prototype.signAndSave.call(receiver, row, opts)).rejects.toThrow(/signing.*enabled/i);
-        expect(receiver.save).not.toHaveBeenCalled();
-        const sign = jest.fn((record) => ({ ...record, signature: "first" }));
-        first.enable(sign);
-        expect(Reflect.get(globalThis, signingKey(name))).toBe(sign);
-        await expect(second.prototype.signAndSave.call(receiver, row, opts)).resolves.toEqual({
-            ...row,
-            signature: "first",
-        });
-        expect(sign).toHaveBeenCalledWith(row);
-        expect(sign.mock.contexts.at(-1)).toBe(second.prototype.constructor);
-        expect(receiver.save).toHaveBeenLastCalledWith({ ...row, signature: "first" }, name === "group-member" ? { ...opts, restoreIfDeleted: true } : opts);
-        // Loading another copy must preserve a signer that is already registered.
-        const third = loadSigningTables()[name];
-        expect(third.prototype).not.toBe(first.prototype);
-        await expect(third.prototype.signAndSave.call(receiver, row)).resolves.toEqual({
-            ...row,
-            signature: "first",
-        });
-        expect(sign.mock.contexts.at(-1)).toBe(third.prototype.constructor);
-        second.enable((record) => ({ ...record, signature: "replacement" }));
-        for (const copy of [first, third]) {
-            await expect(copy.prototype.signAndSave.call(receiver, row)).resolves.toEqual({
-                ...row,
-                signature: "replacement",
-            });
-        }
-        receiver.save.mockClear();
-        const failsOnce = jest
-            .fn((record) => ({ ...record, signature: "recovered" }))
-            .mockImplementationOnce(() => {
-            throw new Error("signing failed");
-        });
-        first.enable(failsOnce);
-        await expect(second.prototype.signAndSave.call(receiver, row)).rejects.toThrow("signing failed");
-        expect(receiver.save).not.toHaveBeenCalled();
-        await expect(third.prototype.signAndSave.call(receiver, row)).resolves.toEqual({
-            ...row,
-            signature: "recovered",
-        });
-        expect(failsOnce).toHaveBeenCalledTimes(2);
-        receiver.save.mockRejectedValueOnce(new Error("save failed"));
-        await expect(second.prototype.signAndSave.call(receiver, row)).rejects.toThrow("save failed");
-        await expect(first.prototype.signAndSave.call(receiver, row)).resolves.toEqual({
-            ...row,
-            signature: "recovered",
-        });
-    });
-    it("keeps the five signer registrations independent", async () => {
-        const first = loadSigningTables();
-        const second = loadSigningTables();
-        for (const name of tableNames) {
-            first[name].enable((record) => ({ ...record, signature: name }));
-        }
-        const receiver = { save: jest.fn(async (record) => record) };
-        for (const name of tableNames) {
-            await expect(second[name].prototype.signAndSave.call(receiver, { name: "Example", signature: "" })).resolves.toEqual({ name: "Example", signature: name });
-        }
-    });
-});

package/dist/data/tool-access.test.d.ts

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

package/dist/data/tool-access.test.js

@@ -1,166 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const access_level_1 = require("./access-level");
-const tool_access_1 = require("./tool-access");
-describe("decideToolAccess", () => {
-    it("allows a direct user call at or below their ceiling", () => {
-        expect((0, tool_access_1.decideToolAccess)({
-            userAccessLevel: access_level_1.AccessLevel.Self,
-            toolAccessLevel: access_level_1.AccessLevel.Admin,
-        }).kind).toBe("allow");
-    });
-    it("denies a tool above the user ceiling", () => {
-        const decision = (0, tool_access_1.decideToolAccess)({
-            userAccessLevel: access_level_1.AccessLevel.Writer,
-            toolAccessLevel: access_level_1.AccessLevel.Admin,
-            assistantAccessLevel: access_level_1.AccessLevel.Writer,
-        });
-        expect(decision.kind).toBe("deny");
-    });
-    it("allows an Assistant to run tools at or below its level", () => {
-        expect((0, tool_access_1.decideToolAccess)({
-            userAccessLevel: access_level_1.AccessLevel.Self,
-            assistantAccessLevel: access_level_1.AccessLevel.Writer,
-            toolAccessLevel: access_level_1.AccessLevel.Writer,
-        }).kind).toBe("allow");
-    });
-    it("requires approval when A < T <= U", () => {
-        const decision = (0, tool_access_1.decideToolAccess)({
-            userAccessLevel: access_level_1.AccessLevel.Self,
-            assistantAccessLevel: access_level_1.AccessLevel.Writer,
-            toolAccessLevel: access_level_1.AccessLevel.Admin,
-        });
-        expect(decision.kind).toBe("approval_required");
-    });
-    it("allows a matching grant to skip another prompt", () => {
-        expect((0, tool_access_1.decideToolAccess)({
-            userAccessLevel: access_level_1.AccessLevel.Self,
-            assistantAccessLevel: access_level_1.AccessLevel.Writer,
-            toolAccessLevel: access_level_1.AccessLevel.Admin,
-            hasMatchingGrant: true,
-        }).kind).toBe("allow");
-    });
-});
-describe("canInvokeAssistant", () => {
-    it("denies users below the Assistant level", () => {
-        expect((0, tool_access_1.canInvokeAssistant)(access_level_1.AccessLevel.Writer, access_level_1.AccessLevel.Admin)).toBe(false);
-        expect((0, tool_access_1.canInvokeAssistant)(access_level_1.AccessLevel.Admin, access_level_1.AccessLevel.Admin)).toBe(true);
-    });
-});
-describe("hashToolArgs", () => {
-    it("is stable for key order", () => {
-        expect((0, tool_access_1.hashToolArgs)({ b: 1, a: 2 })).toBe((0, tool_access_1.hashToolArgs)({ a: 2, b: 1 }));
-    });
-});
-describe("annotateToolAccessDescription", () => {
-    it("appends the required level once", () => {
-        const once = (0, tool_access_1.annotateToolAccessDescription)("Does a thing.", 40);
-        expect(once).toContain("Writer (40)");
-        expect((0, tool_access_1.annotateToolAccessDescription)(once, 40)).toBe(once);
-    });
-});
-test("legacy host admission and descriptions use the preservation request, not a grant", () => {
-    const tool = { authorityPropagation: "preserve" };
-    expect((0, tool_access_1.recordAccessLevel)(tool)).toBe(0);
-    expect((0, tool_access_1.annotateToolAccessDescription)("route", (0, tool_access_1.recordAccessLevel)(tool))).toContain("None (0)");
-    expect((0, tool_access_1.recordAccessLevel)({})).toBe(100);
-    expect((0, tool_access_1.recordAccessLevel)({ ...tool, accessLevel: 40 })).toBe(40);
-});
-describe("recordAccessLevel", () => {
-    it("defaults missing records to 100", () => {
-        expect((0, tool_access_1.recordAccessLevel)(undefined)).toBe(100);
-        expect((0, tool_access_1.recordAccessLevel)({})).toBe(100);
-        expect((0, tool_access_1.recordAccessLevel)({ accessLevel: 20 })).toBe(20);
-    });
-});
-describe("resolveDelegatedAccessLevel", () => {
-    it("omits an Assistant ceiling for direct user calls", () => {
-        expect((0, tool_access_1.resolveDelegatedAccessLevel)({
-            directUser: true,
-            accessAssistantLevel: access_level_1.AccessLevel.Writer,
-            defaultAssistantLevel: access_level_1.AccessLevel.Writer,
-        })).toBeUndefined();
-    });
-    it("takes the lower of access-assistant and default Assistant", () => {
-        expect((0, tool_access_1.resolveDelegatedAccessLevel)({
-            directUser: false,
-            accessAssistantLevel: access_level_1.AccessLevel.Admin,
-            defaultAssistantLevel: access_level_1.AccessLevel.Writer,
-        })).toBe(access_level_1.AccessLevel.Writer);
-    });
-    it("fails closed to None when no Assistant record resolved", () => {
-        expect((0, tool_access_1.resolveDelegatedAccessLevel)({ directUser: false })).toBe(access_level_1.AccessLevel.None);
-    });
-});
-describe("threadRootMessageId", () => {
-    it("uses the parent when present and the message itself when it is the root", () => {
-        expect((0, tool_access_1.threadRootMessageId)({
-            messageId: "00reply0000000000000000001",
-            messageParentId: "00root00000000000000000001",
-        })).toBe("00root00000000000000000001");
-        expect((0, tool_access_1.threadRootMessageId)({ messageId: "00root00000000000000000001" })).toBe("00root00000000000000000001");
-        expect((0, tool_access_1.threadRootMessageId)(undefined)).toBeUndefined();
-    });
-});
-describe("isReservedAccessVarName", () => {
-    it("matches host-owned access keys only", () => {
-        expect((0, tool_access_1.isReservedAccessVarName)(tool_access_1.DIRECT_USER_INVOCATION_VAR)).toBe(true);
-        expect((0, tool_access_1.isReservedAccessVarName)(tool_access_1.ASSISTANT_ID_VAR)).toBe(true);
-        expect((0, tool_access_1.isReservedAccessVarName)("cwd")).toBe(false);
-    });
-});
-describe("omitEphemeralAccessVars", () => {
-    it("strips one-shot host tickets and leaves other vars", () => {
-        expect((0, tool_access_1.omitEphemeralAccessVars)({
-            cwd: "/tmp",
-            [tool_access_1.DIRECT_USER_INVOCATION_VAR]: true,
-            [tool_access_1.HOST_APPROVED_APPROVAL_ID_VAR]: "00testapproval0000000001",
-        })).toEqual({ cwd: "/tmp" });
-        expect((0, tool_access_1.omitEphemeralAccessVars)(undefined)).toEqual({});
-    });
-});
-describe("omitReservedAccessVars", () => {
-    it("strips Assistant identity as well as host tickets", () => {
-        expect((0, tool_access_1.omitReservedAccessVars)({
-            cwd: "/tmp",
-            [tool_access_1.ACCESS_ASSISTANT_ID_VAR]: "assistant-a",
-            [tool_access_1.ASSISTANT_ID_VAR]: "assistant-a",
-            [tool_access_1.DIRECT_USER_INVOCATION_VAR]: true,
-        })).toEqual({ cwd: "/tmp" });
-    });
-});
-describe("inheritAccessVars", () => {
-    it("copies parent authority and does not let child vars escalate", () => {
-        const inherited = (0, tool_access_1.inheritAccessVars)({ [tool_access_1.ACCESS_ASSISTANT_ID_VAR]: "assistant-a", [tool_access_1.DIRECT_USER_INVOCATION_VAR]: false }, "assistant-parent", { [tool_access_1.ACCESS_ASSISTANT_ID_VAR]: "assistant-b", [tool_access_1.DIRECT_USER_INVOCATION_VAR]: true, foo: 1 });
-        expect(inherited[tool_access_1.ACCESS_ASSISTANT_ID_VAR]).toBe("assistant-a");
-        expect(inherited[tool_access_1.ASSISTANT_ID_VAR]).toBe("assistant-a");
-        expect(inherited[tool_access_1.DIRECT_USER_INVOCATION_VAR]).toBe(false);
-        expect(inherited.foo).toBe(1);
-    });
-    it("does not copy a host-approved approval id onto the child", () => {
-        const inherited = (0, tool_access_1.inheritAccessVars)({ [tool_access_1.HOST_APPROVED_APPROVAL_ID_VAR]: "00parentapproval00000001" }, "assistant-parent", { [tool_access_1.HOST_APPROVED_APPROVAL_ID_VAR]: "00childapproval000000001", foo: 1 });
-        expect(inherited[tool_access_1.HOST_APPROVED_APPROVAL_ID_VAR]).toBeUndefined();
-        expect(inherited.foo).toBe(1);
-    });
-    it("ignores a child-supplied assistantId", () => {
-        const inherited = (0, tool_access_1.inheritAccessVars)({ [tool_access_1.ACCESS_ASSISTANT_ID_VAR]: "assistant-a" }, "assistant-parent", {
-            [tool_access_1.ASSISTANT_ID_VAR]: "assistant-admin",
-            foo: 1,
-        });
-        expect(inherited[tool_access_1.ASSISTANT_ID_VAR]).toBe("assistant-a");
-        expect(inherited[tool_access_1.ACCESS_ASSISTANT_ID_VAR]).toBe("assistant-a");
-    });
-});
-describe("approvalRequiredResult", () => {
-    it("includes a model-visible status", () => {
-        const result = (0, tool_access_1.approvalRequiredResult)({
-            approvalId: "000peers0tacapprove000001",
-            toolId: "000peers0tool00000sendmsg",
-            toolName: "send-message",
-            requiredAccessLevel: 60,
-            message: "Needs approval",
-        });
-        expect(result.status).toBe("approval_required");
-        expect(result.requiredAccessLabel).toBe("Admin");
-    });
-});

package/dist/data/user-permissions.test.d.ts

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