@peers-app/peers-sdk 0.25.20 → 0.26.0

package/dist/contracts/__tests__/builder.test.js

@@ -494,7 +494,6 @@ describe("definePackage — error cases", () => {
         });
         expect(result.contracts).toHaveLength(0);
         expect(result.consumes).toHaveLength(0);
-        expect(result.toolInstances).toHaveLength(0);
         expect(result.tableDefinitions).toHaveLength(0);
         expect(result.appNavs).toEqual([nav]);
     });
@@ -505,7 +504,6 @@ describe("definePackage — error cases", () => {
         });
         expect(result.contracts).toHaveLength(0);
         expect(result.consumes).toHaveLength(1);
-        expect(result.toolInstances).toHaveLength(0);
         expect(result.tableDefinitions).toHaveLength(0);
     });
     it("throws on duplicate contract ID + version", () => {

package/dist/contracts/__tests__/contract-provider-router.test.js

@@ -16,6 +16,57 @@ const makeEndpoint = (label) => ({
     dispose: jest.fn(),
 });
 describe("contract provider router", () => {
+    it("refreshes a retired cached endpoint once and shares the new route across concurrent calls", async () => {
+        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
+        const old = makeEndpoint("old");
+        const current = makeEndpoint("current");
+        const resolveEndpoint = jest.fn().mockResolvedValueOnce(old).mockResolvedValue(current);
+        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
+            authorizeCall: () => ({}),
+            resolveEndpoint,
+        });
+        try {
+            expect(await consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).toBe("old:list");
+            old.handleCall.mockRejectedValue(new index_1.RetiredContractProviderEndpointError(old));
+            expect(await Promise.all([
+                consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall()),
+                consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall()),
+            ])).toEqual(["current:list", "current:list"]);
+            expect(resolveEndpoint).toHaveBeenCalledTimes(2);
+            expect(old.dispose).toHaveBeenCalledTimes(1);
+            // Another replacement in the same call fails closed instead of looping.
+            current.handleCall.mockRejectedValue(new index_1.RetiredContractProviderEndpointError(current));
+            await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).rejects.toThrow(/retired/);
+            expect(resolveEndpoint).toHaveBeenCalledTimes(3);
+        }
+        finally {
+            router.dispose();
+        }
+    });
+    it("does not replay provider code when a downstream endpoint retires", async () => {
+        const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
+        const downstream = makeEndpoint("downstream");
+        const endpoint = makeEndpoint("caller");
+        const effects = jest.fn();
+        const failure = new index_1.RetiredContractProviderEndpointError(downstream);
+        endpoint.handleCall.mockImplementation(async () => {
+            effects();
+            throw failure;
+        });
+        const resolveEndpoint = jest.fn().mockResolvedValue(endpoint);
+        const router = (0, index_1.createContractProviderRouter)(providerTransport, {
+            authorizeCall: () => ({}),
+            resolveEndpoint,
+        });
+        try {
+            await expect(consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeCall())).rejects.toBe(failure);
+            expect(resolveEndpoint).toHaveBeenCalledTimes(1);
+            expect(effects).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            router.dispose();
+        }
+    });
     it("multiplexes routes and caches normalized contract/version/data-context endpoints", async () => {
         const [consumerTransport, providerTransport] = (0, index_1.inProcessTransportPair)();
         const endpoints = new Map();

package/dist/contracts/__tests__/contract-proxy.test.js

@@ -634,3 +634,24 @@ describe("connectionContractTransport", () => {
         }));
     });
 });
+test("a provider-local implementation needs no toolId and still enforces access", async () => {
+    const toolFn = jest.fn(() => "bound");
+    const dispatch = (0, contract_proxy_1.createContractProvider)({
+        contractId: CONTRACT_ID,
+        version: 1,
+        tools: { run: { tool: { name: "run", usageDescription: "run", accessLevel: 40 }, toolFn } },
+    });
+    const call = {
+        contractId: CONTRACT_ID,
+        version: 1,
+        member: "tool",
+        name: "run",
+        operation: "run",
+        args: [{}],
+    };
+    jest.spyOn(groupPermissions, "getUserRole").mockResolvedValue(20);
+    await expect(dispatch(call, { callerUserId: (0, utils_1.newid)() })).rejects.toThrow(/Permission denied/);
+    jest.spyOn(groupPermissions, "getUserRole").mockResolvedValue(40);
+    await expect(dispatch(call, { callerUserId: (0, utils_1.newid)() })).resolves.toBe("bound");
+    expect(toolFn).toHaveBeenCalledTimes(1);
+});

package/dist/contracts/__tests__/contract-resolvers.test.js

@@ -167,10 +167,13 @@ describe("Self-trusted contract caller authorization", () => {
     it.each([
         ["Tool Access Control", system_ids_1.toolAccessControlContractId],
         ["Identity", system_ids_1.identityContractId],
+        ["Host Tools", system_ids_1.hostToolsContractId],
+        ["Desktop Tools", system_ids_1.desktopToolsContractId],
         ["Invites", system_ids_1.invitesContractId],
         ["HTTP", system_ids_1.httpContractId],
         ["Scheduler", system_ids_1.schedulerContractId],
         ["Contract Catalog", system_ids_1.contractCatalogContractId],
+        ["Tool Catalog", system_ids_1.toolCatalogContractId],
     ])("rejects remote %s as local-only", async (_name, contractId) => {
         const { remoteIdentity, user } = makeIdentity();
         const records = new Map();
@@ -260,6 +263,42 @@ describe("remote contract call authorization (group members)", () => {
         expect(route.context?.dataContext).toBe(groupDataContext);
         expect(accessLevelMock.calls).toEqual([[groupDataContext, remoteIdentity.userId]]);
     });
+    it("waits for catalog persistence before authorizing a cold group's first call", async () => {
+        const { remoteIdentity, userContext, groupDataContext } = setupGroupMember({
+            remoteAccessLevel: access_level_1.AccessLevel.Writer,
+            callerLevel: access_level_1.AccessLevel.Writer,
+        });
+        let release;
+        const catalogReady = new Promise((resolve) => {
+            release = resolve;
+        });
+        Object.assign(groupDataContext.packageLoader, { catalogReady });
+        const pending = (0, index_1.authorizeRemoteContractCall)(toolCall, userContext, remoteIdentity);
+        try {
+            await new Promise((resolve) => setImmediate(resolve));
+            expect(groupDataContext.packageLoader.contractRegistry.getDefinition).not.toHaveBeenCalled();
+            expect(accessLevelMock.calls).toEqual([]);
+        }
+        finally {
+            release();
+        }
+        await expect(pending).resolves.toMatchObject({ dataContextId: groupId });
+    });
+    it("fails closed on catalog initialization failure and permits a later retry", async () => {
+        const { remoteIdentity, userContext, groupDataContext } = setupGroupMember({
+            remoteAccessLevel: access_level_1.AccessLevel.Writer,
+            callerLevel: access_level_1.AccessLevel.Writer,
+        });
+        let fail = true;
+        Object.defineProperty(groupDataContext.packageLoader, "catalogReady", {
+            get: () => (fail ? Promise.reject(new Error("catalog unavailable")) : Promise.resolve()),
+        });
+        await expect((0, index_1.authorizeRemoteContractCall)(toolCall, userContext, remoteIdentity)).rejects.toThrow("catalog unavailable");
+        expect(groupDataContext.packageLoader.contractRegistry.getDefinition).not.toHaveBeenCalled();
+        expect(accessLevelMock.calls).toEqual([]);
+        fail = false;
+        await expect((0, index_1.authorizeRemoteContractCall)(toolCall, userContext, remoteIdentity)).resolves.toMatchObject({ dataContextId: groupId });
+    });
     it("denies a group member below the tool's remoteAccessLevel", async () => {
         const { remoteIdentity, userContext } = setupGroupMember({
             remoteAccessLevel: access_level_1.AccessLevel.Admin,
@@ -388,6 +427,51 @@ describe("local user-context contract routing", () => {
         await expect(result).resolves.toBe(setup.userId);
         router.dispose();
     });
+    it.each([
+        false,
+        true,
+    ])("waits for catalog readiness before provider selection (explicit=%s)", async (explicit) => {
+        const setup = setupLocalRouter();
+        const providerPackageId = (0, utils_1.newid)();
+        let release;
+        const catalogReady = new Promise((resolve) => {
+            release = resolve;
+        });
+        const getRegisteredProviderIds = jest.fn(() => [providerPackageId]);
+        const getActiveContractProviderPackageId = jest.fn(() => providerPackageId);
+        const handleCall = jest.fn(async () => "ready");
+        const resolveContractEndpoint = jest.fn(async () => ({ handleCall, dispose() { } }));
+        setup.userContext.userDataContext.packageLoader = {
+            catalogReady,
+            contractRegistry: { getRegisteredProviderIds },
+            getActiveContractProviderPackageId,
+            resolveContractEndpoint,
+        };
+        const router = (0, index_1.createLocalUserContextContractProviderRouter)(setup.providerTransport, {
+            getUserContext: async () => setup.userContext,
+        });
+        try {
+            const pending = setup.consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, {
+                ...makeToolCall(setup.contractId),
+                ...(explicit ? { providerPackageId } : {}),
+            });
+            try {
+                await new Promise((resolve) => setImmediate(resolve));
+                expect(getRegisteredProviderIds).not.toHaveBeenCalled();
+                expect(getActiveContractProviderPackageId).not.toHaveBeenCalled();
+                expect(resolveContractEndpoint).not.toHaveBeenCalled();
+            }
+            finally {
+                release();
+            }
+            await expect(pending).resolves.toBe("ready");
+            expect(resolveContractEndpoint).toHaveBeenCalledWith(expect.objectContaining({ providerPackageId }), expect.anything());
+            expect(handleCall).toHaveBeenCalledTimes(1);
+        }
+        finally {
+            router.dispose();
+        }
+    });
     it("resolves a signed-out contract without waiting for a user context", async () => {
         const contractId = (0, utils_1.newid)();
         (0, index_1.registerContractResolver)(contractId, 1, () => ({

package/dist/contracts/__tests__/legacy-removal.test.d.ts

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

package/dist/contracts/__tests__/legacy-removal.test.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk = require("../../index");
+const utils_1 = require("../../utils");
+const builder_1 = require("../builder");
+const registry_1 = require("../registry");
+const tool_catalog_1 = require("../tool-catalog");
+const tool_catalog_migrations_1 = require("../tool-catalog-migrations");
+const removedRegistryExports = [
+    "registerTool",
+    "getRegisteredTool",
+    "unregisterTools",
+    "getAllRegisteredTools",
+    "clearRegisteredTools",
+    "tools",
+];
+test("the SDK exports no executable registry", () => {
+    for (const name of removedRegistryExports)
+        expect(sdk).not.toHaveProperty(name);
+});
+test("old SDK assignments warn once and never produce executables", () => {
+    const builder = new builder_1.ContractBuilder((0, utils_1.newid)(), 1, "Old package");
+    const warn = jest.spyOn(console, "warn").mockImplementation(() => { });
+    try {
+        builder.toolInstances = [{ toolFn: jest.fn() }];
+        builder.toolInstances = [];
+        expect(warn).toHaveBeenCalledTimes(1);
+        expect(warn).toHaveBeenCalledWith(expect.stringContaining(`Contract Old package (${builder.contractId}@1) assigned toolInstances, which no longer run`));
+        expect(builder._build()).not.toHaveProperty("toolInstances");
+    }
+    finally {
+        warn.mockRestore();
+    }
+});
+test("runner metadata uses the shape target and ignores arbitrary tool IDs", () => {
+    const contractId = (0, utils_1.newid)();
+    const shape = {
+        tool: {
+            toolId: (0, utils_1.newid)(),
+            name: "runner",
+            usageDescription: "run",
+            isAssistantRunner: true,
+            configSchema: { type: sdk.IOSchemaType.none, fields: [] },
+            detailedDescription: "details",
+        },
+    };
+    const result = (0, builder_1.definePackage)((pkg) => {
+        pkg.packageId = (0, utils_1.newid)();
+        pkg.contract(contractId, 1, "Runner").tools = [shape];
+    });
+    const target = { contractId, version: 1, toolName: "runner" };
+    expect(result.toolMetadata).toEqual([
+        {
+            ...target,
+            isAssistantRunner: true,
+            configSchema: shape.tool.configSchema,
+            detailedDescription: "details",
+        },
+    ]);
+    expect(result).not.toHaveProperty("toolInstances");
+    expect((0, tool_catalog_migrations_1.toolCatalogIds)(target)).not.toContain(shape.tool.toolId);
+    shape.tool.toolId = (0, utils_1.newid)();
+    expect((0, tool_catalog_migrations_1.toolCatalogIds)(target)).toEqual([sdk.deriveToolCatalogId(target)]);
+});
+test("metadata targeting another publication is rejected before any catalog write", async () => {
+    const getTable = jest.fn();
+    const registry = new registry_1.ContractRegistry();
+    const catalog = new tool_catalog_1.ToolCatalog({ tableContainer: { getTable } }, registry);
+    const definition = (0, builder_1.definePackage)((pkg) => {
+        pkg.packageId = (0, utils_1.newid)();
+        pkg.contract((0, utils_1.newid)(), 1, "Own").tools = [{ tool: { name: "own", usageDescription: "own" } }];
+    });
+    const foreign = {
+        ...definition.contracts[0],
+        contractId: (0, utils_1.newid)(),
+        tools: [{ ...definition.contracts[0].tools[0], name: "foreign" }],
+    };
+    expect(registry.register((0, utils_1.newid)(), foreign).valid).toBe(true);
+    const prepare = jest.fn();
+    const activate = jest.fn();
+    try {
+        await expect(catalog.publish(definition.packageId, definition.contracts.map((definition) => ({ definition })), prepare, activate, [{ contractId: foreign.contractId, version: 1, toolName: "foreign" }])).rejects.toThrow(/member of this publication/);
+        expect(getTable).not.toHaveBeenCalled();
+        expect(prepare).not.toHaveBeenCalled();
+        expect(activate).not.toHaveBeenCalled();
+    }
+    finally {
+        await catalog.dispose();
+    }
+});

package/dist/contracts/__tests__/system-contracts.test.js

@@ -6,6 +6,7 @@ const contract_resolvers_1 = require("../contract-resolvers");
 const registry_1 = require("../registry");
 const identity_contract_1 = require("../system/identity-contract");
 const system_contracts_1 = require("../system-contracts");
+const tool_catalog_1 = require("../tool-catalog");
 // Populate the catalog with built-in system contracts.
 require("../system");
 describe("system contract catalog", () => {
@@ -17,9 +18,12 @@ describe("system contract catalog", () => {
             system_ids_1.logsContractId,
             system_ids_1.deviceOperationsContractId,
             system_ids_1.identityContractId,
+            system_ids_1.hostToolsContractId,
+            system_ids_1.desktopToolsContractId,
             system_ids_1.networkDiagnosticsContractId,
             system_ids_1.networkControlContractId,
             system_ids_1.toolAccessControlContractId,
+            system_ids_1.toolCatalogContractId,
         ]));
     });
     it("registers the Logs live resolver", async () => {
@@ -76,3 +80,87 @@ describe("system contract catalog", () => {
         expect(registry.getProviderPackageId(fakeContractId, 1)).toBe(providerPackageId);
     });
 });
+test("system catalog initialization retries without publishing on failed persistence", async () => {
+    const rows = new Map();
+    let fail = true;
+    const context = {
+        tableContainer: {
+            getTable: () => ({
+                list: async () => [...rows.values()],
+                get: async (toolId) => rows.get(toolId),
+                save: async (row) => {
+                    if (fail)
+                        throw new Error("storage unavailable");
+                    rows.set(row.toolId, row);
+                    return row;
+                },
+                dataChanged: { subscribe: () => ({ unsubscribe: () => true }) },
+            }),
+        },
+    };
+    const registry = new registry_1.ContractRegistry();
+    const catalog = new tool_catalog_1.ToolCatalog(context, registry);
+    await expect((0, system_contracts_1.installSystemContracts)(registry)).rejects.toThrow("storage unavailable");
+    expect(registry.getProviderPackageId(system_ids_1.deviceOperationsContractId, 1)).toBeUndefined();
+    fail = false;
+    await (0, system_contracts_1.installSystemContracts)(registry);
+    expect(registry.getProviderPackageId(system_ids_1.deviceOperationsContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
+    expect(registry.getProviderPackageId(system_ids_1.identityContractId, 1)).toBe(system_ids_1.peersSystemPackageId);
+    expect([...rows.values()].some((row) => row.contractId === system_ids_1.toolAccessControlContractId)).toBe(true);
+    await catalog.dispose();
+});
+test("a later system provider's persistence failure does not publish an earlier provider", async () => {
+    const contractId = (0, utils_1.newid)();
+    const providerPackageId = (0, utils_1.newid)();
+    (0, system_contracts_1.registerSystemContract)({
+        contractId,
+        version: 1,
+        providerPackageId,
+        getDefinition: () => ({
+            contractId,
+            version: 1,
+            name: "Later system provider",
+            description: "",
+            tables: [],
+            observables: [],
+            tools: [{ name: "read", usageDescription: "", inputFields: [], outputFields: [] }],
+        }),
+    });
+    const rows = new Map();
+    const registry = new registry_1.ContractRegistry();
+    const context = {
+        tableContainer: {
+            getTable: () => ({
+                list: async () => [...rows.values()],
+                save: async (row) => {
+                    if (row.contractId === contractId)
+                        throw new Error("late persistence failure");
+                    rows.set(row.toolId, row);
+                    return row;
+                },
+            }),
+        },
+    };
+    const catalog = new tool_catalog_1.ToolCatalog(context, registry);
+    try {
+        await expect(catalog.ready()).rejects.toThrow(/late persistence failure/);
+        expect(rows.size).toBeGreaterThan(0);
+        expect(registry.getProviderPackageId(system_ids_1.deviceOperationsContractId, 1)).toBeUndefined();
+        expect(registry.getProviderPackageId(contractId, 1)).toBeUndefined();
+    }
+    finally {
+        await catalog.dispose();
+    }
+});
+test("host and desktop workflow members are present with workflow-only policy", () => {
+    const registry = new registry_1.ContractRegistry();
+    (0, system_contracts_1.installSystemContracts)(registry);
+    for (const [id, names] of [
+        [system_ids_1.hostToolsContractId, ["default_assistant_runner", "tool-search"]],
+        [system_ids_1.desktopToolsContractId, ["cd", "send-notification"]],
+    ]) {
+        const definition = registry.resolve(id, 1);
+        for (const name of names)
+            expect(definition?.tools.find((tool) => tool.name === name)?.requiresWorkflowRun).toBe(true);
+    }
+});

package/dist/contracts/__tests__/tool-catalog-inventory.test.d.ts

@@ -0,0 +1 @@
+import "../../index";

package/dist/contracts/__tests__/tool-catalog-inventory.test.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../../index");
+const systemIds = require("../../system-ids");
+const system_ids_1 = require("../../system-ids");
+const system_contracts_1 = require("../system-contracts");
+const tool_catalog_identity_1 = require("../tool-catalog-identity");
+const tool_catalog_migrations_1 = require("../tool-catalog-migrations");
+test("every reviewed alias is valid and the workflow migration leaves no unresolved tools", () => {
+    for (const entry of tool_catalog_migrations_1.toolCatalogMigrations) {
+        expect((0, tool_catalog_identity_1.isCatalogToolId)(entry.toolId)).toBe(true);
+        expect((0, tool_catalog_migrations_1.resolveLegacyToolId)(entry.toolId)).toEqual({
+            contractId: entry.contractId,
+            version: entry.version,
+            toolName: entry.toolName,
+        });
+    }
+    for (const [id, contractId, toolName] of [
+        ["000peers0tool00000runner1", system_ids_1.hostToolsContractId, "default_assistant_runner"],
+        ["000peers0tool00toolsearch", system_ids_1.hostToolsContractId, "tool-search"],
+        ["000peers0tool0000000dircd", system_ids_1.desktopToolsContractId, "cd"],
+        ["000peers0tool000000notify", system_ids_1.desktopToolsContractId, "send-notification"],
+    ])
+        expect((0, tool_catalog_migrations_1.resolveLegacyToolId)(id)).toEqual({ contractId, version: 1, toolName });
+});
+test("all system aliases name declared members and every system ID map is reviewed", () => {
+    for (const alias of tool_catalog_migrations_1.toolCatalogMigrations) {
+        if (!(0, system_contracts_1.isSystemContractId)(alias.contractId))
+            continue;
+        const system = (0, system_contracts_1.listSystemContracts)().find((entry) => {
+            const definition = entry.getDefinition();
+            return definition.contractId === alias.contractId && definition.version === alias.version;
+        });
+        expect(system).toBeDefined();
+        expect(system?.getDefinition().tools.some((tool) => tool.name === alias.toolName)).toBe(true);
+    }
+    for (const [name, ids] of Object.entries(systemIds)) {
+        if (!name.endsWith("ToolIds"))
+            continue;
+        for (const toolId of Object.values(ids))
+            expect((0, tool_catalog_migrations_1.resolveLegacyToolId)(toolId)).toBeDefined();
+    }
+    expect((0, tool_catalog_migrations_1.resolveLegacyToolId)("00mh0wlipkdbeaw8imptsk001")).toBeUndefined();
+});

package/dist/contracts/__tests__/tool-catalog-service.test.d.ts

@@ -0,0 +1 @@
+import "../../index";