@peers-app/peers-sdk 0.21.7 → 0.22.0

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

@@ -239,4 +239,39 @@ describe("local user-context contract routing", () => {
         await expect(setup.consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, makeToolCall(setup.contractId))).rejects.toThrow("contract");
         router.dispose();
     });
+    it("appends host-only variable access to local package tool calls", async () => {
+        const setup = setupLocalRouter();
+        const resolveVariable = jest.fn(async ({ dataContext, variableName, requestingToolId }) => [dataContext.dataContextId, variableName, requestingToolId].join(":"));
+        (0, index_1.registerContractResolver)(setup.contractId, 1, () => ({
+            contractId: setup.contractId,
+            version: 1,
+            tools: {
+                inspect: {
+                    tool: {
+                        toolId: "00localcontractsecrettool",
+                        name: "inspect",
+                        usageDescription: "Resolve a local variable.",
+                        inputSchema: { type: "simple", fields: [] },
+                        outputSchema: { type: "simple", fields: [] },
+                        code: "",
+                    },
+                    toolFn: async (variableName, context) => context.getVariable(variableName, "00localcontractsecrettool"),
+                },
+            },
+        }));
+        const router = (0, index_1.createLocalUserContextContractProviderRouter)(setup.providerTransport, {
+            getUserContext: async () => setup.userContext,
+            resolveVariable,
+        });
+        await expect(setup.consumerTransport.emit(index_1.CONTRACT_REQUEST_CHANNEL, {
+            ...makeToolCall(setup.contractId),
+            args: ["OPENAI_API_KEY"],
+        })).resolves.toBe(`${setup.userId}:OPENAI_API_KEY:00localcontractsecrettool`);
+        expect(resolveVariable).toHaveBeenCalledWith(expect.objectContaining({
+            dataContext: expect.objectContaining({ dataContextId: setup.userId }),
+            variableName: "OPENAI_API_KEY",
+            requestingToolId: "00localcontractsecrettool",
+        }));
+        router.dispose();
+    });
 });

package/dist/contracts/contract-proxy.d.ts

@@ -195,6 +195,22 @@ export interface IContractConsumer extends IContractConsumerBase {
         subscribe: (handler: (value: any) => void) => ISubscriptionResult;
     }>;
 }
+/**
+ * Trusted host capabilities appended to local package-contract tool calls.
+ *
+ * The context is constructed by the provider host after it authorizes the data-context
+ * route. It is never serialized to the consumer and is intentionally absent for remote
+ * contract calls unless a host explicitly opts in.
+ */
+export interface IContractToolContext {
+    /** Authorized data context in which the tool is executing. */
+    dataContextId: string;
+    /**
+     * Resolve a persistent variable in the authorized context. Secret values are decrypted
+     * by the host and returned only to the provider-side tool implementation.
+     */
+    getVariable(variableName: string, requestingToolId: string): Promise<string>;
+}
 /**
  * Build the **consumer** side of a contract proxy from a contract definition and a
  * transport. Member names come from the contract shape; table members are backed by a
@@ -234,6 +250,11 @@ export interface IContractResolution {
     version: number;
     tables?: Record<string, Table<any>>;
     tools?: Record<string, IToolInstance>;
+    /**
+     * Host-only capabilities appended as the final argument to provider tool functions.
+     * Omit this for remote or otherwise untrusted provider routes.
+     */
+    toolContext?: IContractToolContext;
     observables?: Record<string, Observable<any>>;
     /**
      * Provider-owned write policy for live observables. A `set` is allowed only when the

package/dist/contracts/contract-proxy.js

@@ -394,7 +394,9 @@ function createContractProvider(resolution, opts = {}) {
                 if (!tool) {
                     throw new Error(`Contract ${call.contractId} does not provide tool '${call.name}'`);
                 }
-                return tool.toolFn(...call.args);
+                return resolution.toolContext
+                    ? tool.toolFn(...call.args, resolution.toolContext)
+                    : tool.toolFn(...call.args);
             }
             case "observable": {
                 const obs = resolution.observables?.[call.name];

package/dist/contracts/contract-resolvers.d.ts

@@ -12,6 +12,14 @@ import type { IContractTransport } from "./contract-transport";
 export type ContractResolver = (ctx: {
     dataContext: DataContext;
 }) => IContractResolution | Promise<IContractResolution>;
+/** Input supplied to a trusted local host when a package tool resolves a pvar. */
+export interface ILocalContractVariableRequest {
+    dataContext: DataContext;
+    variableName: string;
+    requestingToolId: string;
+}
+/** Host callback that resolves plaintext only inside a local provider process. */
+export type LocalContractVariableResolver = (request: ILocalContractVariableRequest) => Promise<string>;
 /** Connection-authenticated identity fields used to authorize remote contract calls. */
 export type ContractRemoteIdentity = Pick<IDeviceInfo, "deviceId" | "userId" | "publicKey" | "publicBoxKey">;
 /**
@@ -45,10 +53,12 @@ export declare function isSelfTrustedContractCaller(userContext: UserContext, re
  * @param transport Contract transport backed by an authenticated local session.
  * @param opts.getUserContext Lazy accessor for the host's loaded user context.
  * @param opts.allowedContractIds Optional contract allowlist for this session.
+ * @param opts.resolveVariable Optional host-only pvar resolver exposed to local package tools.
  */
 export declare function createLocalUserContextContractProviderRouter(transport: IContractTransport, opts: {
     getUserContext: () => Promise<UserContext>;
     allowedContractIds?: ReadonlySet<string>;
+    resolveVariable?: LocalContractVariableResolver;
 }): IContractProviderRouter;
 /**
  * Create the local-object provider router for one verified device connection.

package/dist/contracts/contract-resolvers.js

@@ -100,9 +100,10 @@ function getAuthorizedLocalDataContext(userContext, requestedId) {
  * @param transport Contract transport backed by an authenticated local session.
  * @param opts.getUserContext Lazy accessor for the host's loaded user context.
  * @param opts.allowedContractIds Optional contract allowlist for this session.
+ * @param opts.resolveVariable Optional host-only pvar resolver exposed to local package tools.
  */
 function createLocalUserContextContractProviderRouter(transport, opts) {
-    const { getUserContext, allowedContractIds } = opts;
+    const { getUserContext, allowedContractIds, resolveVariable } = opts;
     return (0, contract_provider_router_1.createContractProviderRouter)(transport, {
         authorizeCall: async (call) => {
             if (allowedContractIds && !allowedContractIds.has(call.contractId)) {
@@ -127,7 +128,16 @@ function createLocalUserContextContractProviderRouter(transport, opts) {
             }
             const dataContext = getAuthorizedLocalDataContext(userContext, dataContextId);
             const resolution = await resolver({ dataContext });
-            return (0, contract_proxy_1.createContractProviderEndpoint)(resolution, { context, notify });
+            const localResolution = resolveVariable
+                ? {
+                    ...resolution,
+                    toolContext: {
+                        dataContextId: dataContext.dataContextId,
+                        getVariable: (variableName, requestingToolId) => resolveVariable({ dataContext, variableName, requestingToolId }),
+                    },
+                }
+                : resolution;
+            return (0, contract_proxy_1.createContractProviderEndpoint)(localResolution, { context, notify });
         },
     });
 }

package/dist/contracts/index.d.ts

@@ -1,8 +1,8 @@
 export { ContractBuilder, definePackage, PackageBuilder } from "./builder";
 export { type ContractCallAuthorizer, type ContractProviderEndpointResolver, createContractProviderRouter, type IAuthorizedContractRoute, type IContractProviderEndpointRequest, type IContractProviderRouter, type IContractProviderRouterOptions, } from "./contract-provider-router";
 export { ContractProviders, ContractProvidersTable, contractProvidersMetaData, contractProvidersSchema, type IContractProviderRecord, } from "./contract-providers.table";
-export { CONTRACT_CALL_RPC, type ContractMemberType, type ContractNotificationSink, type ContractPermissionCheck, createContractConsumer, createContractProvider, createContractProviderEndpoint, createContractProviderSession, type IContractCall, type IContractCallContext, type IContractConsumer, type IContractConsumerBase, type IContractNotification, type IContractProviderEndpoint, type IContractProviderEndpointOptions, type IContractProviderSession, type IContractProviderSessionOptions, type IContractResolution, type IContractTableProxy, type ITableProxy, sameUserContractPermissionCheck, } from "./contract-proxy";
-export { type ContractRemoteIdentity, type ContractResolver, createLocalUserContextContractProviderRouter, createUserContextContractProviderRouter, getContractResolver, handleContractCall, isSelfTrustedContractCaller, registerContractResolver, } from "./contract-resolvers";
+export { CONTRACT_CALL_RPC, type ContractMemberType, type ContractNotificationSink, type ContractPermissionCheck, createContractConsumer, createContractProvider, createContractProviderEndpoint, createContractProviderSession, type IContractCall, type IContractCallContext, type IContractConsumer, type IContractConsumerBase, type IContractNotification, type IContractProviderEndpoint, type IContractProviderEndpointOptions, type IContractProviderSession, type IContractProviderSessionOptions, type IContractResolution, type IContractTableProxy, type IContractToolContext, type ITableProxy, sameUserContractPermissionCheck, } from "./contract-proxy";
+export { type ContractRemoteIdentity, type ContractResolver, createLocalUserContextContractProviderRouter, createUserContextContractProviderRouter, getContractResolver, handleContractCall, type ILocalContractVariableRequest, isSelfTrustedContractCaller, type LocalContractVariableResolver, registerContractResolver, } from "./contract-resolvers";
 export { CONTRACT_NOTIFY_CHANNEL, CONTRACT_REQUEST_CHANNEL, connectionContractTransport, type IContractTransport, type IDuplexEmitter, inProcessTransportPair, } from "./contract-transport";
 export { Contracts, ContractsTable, contractsMetaData, contractsSchema, type IContractRecord, } from "./contracts.table";
 export { createLocalContractConsumer } from "./create-local-consumer";

package/dist/data/index.d.ts

@@ -25,7 +25,6 @@ export * from "./tools";
 export * from "./user-permissions";
 export * from "./user-trust-levels";
 export * from "./users";
-export * from "./voice-messages";
 export * from "./welcome-modal.pvar";
 export * from "./workflow-logs";
 export * from "./workflow-runs";

package/dist/data/index.js

@@ -41,7 +41,6 @@ __exportStar(require("./tools"), exports);
 __exportStar(require("./user-permissions"), exports);
 __exportStar(require("./user-trust-levels"), exports);
 __exportStar(require("./users"), exports);
-__exportStar(require("./voice-messages"), exports);
 __exportStar(require("./welcome-modal.pvar"), exports);
 __exportStar(require("./workflow-logs"), exports);
 __exportStar(require("./workflow-runs"), exports);

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

@@ -12,11 +12,42 @@ export declare function nameToFolderSlug(name: string): string;
  * @returns The path to the cached template directory.
  */
 export declare function ensureTemplateCache(deps: IPackageInstallerDeps, templateRepo: string): Promise<string>;
+/**
+ * Resolve (or create) the Ed25519 publish public key for a package.
+ *
+ * Idempotent: never rotates an established key. Reuses `existingPublishPublicKey`
+ * when present, derives the public key from an existing secret pvar when possible,
+ * and only generates a new keypair when both are missing.
+ *
+ * @throws When a readable secret key does not match an established `publishPublicKey`.
+ */
+export declare function ensurePackageSigningKey(opts: {
+    personalContext?: DataContext;
+    packageId: string;
+    packageName: string;
+    existingPublishPublicKey?: string;
+}): Promise<string>;
+/**
+ * Import an existing on-disk Peers package directory into the current data context.
+ *
+ * Validates the manifest packageId, creates/updates the Packages record, persists
+ * `packageLocalPath_*`, provisions a signing key when missing, then installs the
+ * local dev bundles.
+ */
+export declare function importExistingPackage(dataContext: DataContext, deps: IPackageInstallerDeps, opts: {
+    location: string;
+    personalContext?: DataContext;
+    /** Display name fallback when the manifest name is a slug. */
+    displayName?: string;
+}): Promise<ICreatePackageResult>;
 /**
  * Create a new Peers package from the package template.
  *
  * Clones the template repo, patches IDs and metadata, runs npm install + build,
  * initializes a fresh git repo, then delegates to {@link installPackageFromBundles}
  * to register the dev bundle in the database.
+ *
+ * When `location` already exists and contains a valid Peers package manifest,
+ * imports that directory instead (see {@link importExistingPackage}).
  */
 export declare function createPackage(dataContext: DataContext, deps: IPackageInstallerDeps, opts: ICreatePackageOpts): Promise<ICreatePackageResult>;

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

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nameToFolderSlug = nameToFolderSlug;
 exports.ensureTemplateCache = ensureTemplateCache;
+exports.ensurePackageSigningKey = ensurePackageSigningKey;
+exports.importExistingPackage = importExistingPackage;
 exports.createPackage = createPackage;
 const packages_1 = require("../data/packages");
 const persistent_vars_1 = require("../data/persistent-vars");
@@ -42,29 +44,148 @@ async function ensureTemplateCache(deps, templateRepo) {
     }
     return cachePath;
 }
+/**
+ * Resolve (or create) the Ed25519 publish public key for a package.
+ *
+ * Idempotent: never rotates an established key. Reuses `existingPublishPublicKey`
+ * when present, derives the public key from an existing secret pvar when possible,
+ * and only generates a new keypair when both are missing.
+ *
+ * @throws When a readable secret key does not match an established `publishPublicKey`.
+ */
+async function ensurePackageSigningKey(opts) {
+    const { personalContext, packageId, packageName, existingPublishPublicKey } = opts;
+    const establishedKey = existingPublishPublicKey?.trim() || "";
+    if (personalContext) {
+        const keyName = `${package_author_signing_1.PACKAGE_SIGNING_KEY_PREFIX}${packageId}`;
+        const existingKey = await (0, persistent_vars_1.PersistentVars)(personalContext).findOne({ name: keyName });
+        const rawSecret = existingKey?.value?.value;
+        if (typeof rawSecret === "string" && rawSecret.length > 0) {
+            try {
+                const derivedPublicKey = (0, keys_1.hydrateKeys)(rawSecret).publicKey;
+                if (establishedKey && derivedPublicKey !== establishedKey) {
+                    throw new Error(`Package signing key mismatch for "${packageName}" (${packageId}): ` +
+                        "stored secret does not match Packages.publishPublicKey. " +
+                        "Refusing to rotate the established key.");
+                }
+                return establishedKey || derivedPublicKey;
+            }
+            catch (err) {
+                if (err instanceof Error && err.message.includes("signing key mismatch")) {
+                    throw err;
+                }
+                // Secret is likely encrypted at rest — cannot derive here without the user key.
+                if (establishedKey) {
+                    return establishedKey;
+                }
+                throw new Error(`Package "${packageName}" (${packageId}) has a signing secret pvar but no ` +
+                    "publishPublicKey, and the secret could not be hydrated. " +
+                    "Restore publishPublicKey or replace the unreadable key before importing.");
+            }
+        }
+    }
+    if (establishedKey) {
+        return establishedKey;
+    }
+    if (!personalContext) {
+        return "";
+    }
+    const keys = (0, keys_1.newKeys)();
+    const keyName = `${package_author_signing_1.PACKAGE_SIGNING_KEY_PREFIX}${packageId}`;
+    await (0, persistent_vars_1.PersistentVars)(personalContext).save({
+        persistentVarId: (0, utils_1.deterministicPvarId)(keyName),
+        name: keyName,
+        scope: "user",
+        value: { value: keys.secretKey },
+        isSecret: true,
+        description: `Signing key for package "${packageName}"`,
+        modifiedAt: Date.now(),
+    });
+    return keys.publicKey;
+}
+async function registerPackageRecord(dataContext, opts) {
+    const { packageId, name, description, publishPublicKey, remoteRepo, existing } = opts;
+    await (0, packages_1.Packages)(dataContext).signAndSave({
+        packageId,
+        name,
+        description: description || existing?.description || "",
+        createdBy: existing?.createdBy || system_ids_1.peersRootUserId,
+        disabled: existing?.disabled ?? false,
+        remoteRepo: remoteRepo || existing?.remoteRepo,
+        activePackageVersionId: existing?.activePackageVersionId,
+        versionFollowRange: existing?.versionFollowRange,
+        followVersionTags: existing?.followVersionTags,
+        updateUrl: existing?.updateUrl,
+        publishPublicKey: publishPublicKey || existing?.publishPublicKey || "",
+        signature: existing?.signature || "",
+    }, { restoreIfDeleted: true, saveAsSnapshot: true });
+}
+async function persistPackageLocalPath(dataContext, deps, packageId, location) {
+    const pvar = (0, persistent_vars_1.groupDeviceVar)(`packageLocalPath_${packageId}`, {
+        defaultValue: deps.packagesRootDir,
+        dataContext,
+    });
+    await pvar.loadingPromise;
+    pvar(location);
+}
+/**
+ * Import an existing on-disk Peers package directory into the current data context.
+ *
+ * Validates the manifest packageId, creates/updates the Packages record, persists
+ * `packageLocalPath_*`, provisions a signing key when missing, then installs the
+ * local dev bundles.
+ */
+async function importExistingPackage(dataContext, deps, opts) {
+    const info = await (0, package_installer_1.getPackageInfo)(deps, opts.location);
+    if (!info.packageId) {
+        throw new Error(`Directory already exists at ${opts.location} but does not contain a valid Peers package`);
+    }
+    const packageId = info.packageId;
+    const existing = await (0, packages_1.Packages)(dataContext).get(packageId);
+    const packageName = opts.displayName || info.name || packageId;
+    const publishPublicKey = await ensurePackageSigningKey({
+        personalContext: opts.personalContext,
+        packageId,
+        packageName,
+        existingPublishPublicKey: existing?.publishPublicKey,
+    });
+    await registerPackageRecord(dataContext, {
+        packageId,
+        name: packageName,
+        description: info.description || "",
+        publishPublicKey,
+        remoteRepo: info.remoteRepo,
+        existing,
+    });
+    await persistPackageLocalPath(dataContext, deps, packageId, opts.location);
+    const result = await (0, package_installer_1.installPackageFromBundles)(dataContext, deps, packageId, {
+        localPath: opts.location,
+    });
+    return {
+        packageId,
+        localPath: opts.location,
+        packageVersion: result.packageVersion,
+    };
+}
 /**
  * Create a new Peers package from the package template.
  *
  * Clones the template repo, patches IDs and metadata, runs npm install + build,
  * initializes a fresh git repo, then delegates to {@link installPackageFromBundles}
  * to register the dev bundle in the database.
+ *
+ * When `location` already exists and contains a valid Peers package manifest,
+ * imports that directory instead (see {@link importExistingPackage}).
  */
 async function createPackage(dataContext, deps, opts) {
     const location = opts.location ?? deps.resolvePath(deps.packagesRootDir, nameToFolderSlug(opts.name));
     // If directory already exists, treat as an import rather than a fresh create
     if (await deps.fs.exists(location)) {
-        const info = await (0, package_installer_1.getPackageInfo)(deps, location);
-        if (info.packageId) {
-            const result = await (0, package_installer_1.installPackageFromBundles)(dataContext, deps, info.packageId, {
-                localPath: location,
-            });
-            return {
-                packageId: info.packageId,
-                localPath: location,
-                packageVersion: result.packageVersion,
-            };
-        }
-        throw new Error(`Directory already exists at ${location} but does not contain a valid Peers package`);
+        return importExistingPackage(dataContext, deps, {
+            location,
+            personalContext: opts.personalContext,
+            displayName: opts.name,
+        });
     }
     // Generate fresh IDs
     const packageId = (0, utils_1.newid)();
@@ -110,39 +231,18 @@ async function createPackage(dataContext, deps, opts) {
     await deps.shell.exec("git init", { cwd: location });
     await deps.shell.exec("git add .", { cwd: location });
     await deps.shell.exec('git commit -m "Initial commit"', { cwd: location });
-    // Generate signing keypair and store secret in user's personal group
-    let publishPublicKey = "";
-    if (opts.personalContext) {
-        const keys = (0, keys_1.newKeys)();
-        publishPublicKey = keys.publicKey;
-        const keyName = `${package_author_signing_1.PACKAGE_SIGNING_KEY_PREFIX}${packageId}`;
-        await (0, persistent_vars_1.PersistentVars)(opts.personalContext).save({
-            persistentVarId: (0, utils_1.deterministicPvarId)(keyName),
-            name: keyName,
-            scope: "user",
-            value: { value: keys.secretKey },
-            isSecret: true,
-            description: `Signing key for package "${opts.name}"`,
-            modifiedAt: Date.now(),
-        });
-    }
-    // Register the package record
-    await (0, packages_1.Packages)(dataContext).signAndSave({
+    const publishPublicKey = await ensurePackageSigningKey({
+        personalContext: opts.personalContext,
+        packageId,
+        packageName: opts.name,
+    });
+    await registerPackageRecord(dataContext, {
         packageId,
         name: opts.name,
         description: "",
-        createdBy: system_ids_1.peersRootUserId,
-        disabled: false,
         publishPublicKey,
-        signature: "",
-    }, { restoreIfDeleted: true, saveAsSnapshot: true });
-    // Set the packageLocalPath device var
-    const pvar = (0, persistent_vars_1.groupDeviceVar)(`packageLocalPath_${packageId}`, {
-        defaultValue: deps.packagesRootDir,
-        dataContext,
     });
-    await pvar.loadingPromise;
-    pvar(location);
+    await persistPackageLocalPath(dataContext, deps, packageId, location);
     // Install the dev bundle
     const result = await (0, package_installer_1.installPackageFromBundles)(dataContext, deps, packageId, {
         localPath: location,

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

@@ -3,17 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const package_creator_1 = require("./package-creator");
 // --- Mocks for SDK internals ---
 const mockSignAndSavePkg = jest.fn();
+const mockGetPkg = jest.fn();
 jest.mock("../data/packages", () => ({
     Packages: () => ({
         signAndSave: mockSignAndSavePkg,
+        get: mockGetPkg,
     }),
 }));
 const mockGroupDeviceVar = jest.fn();
 const mockPersistentVarsSave = jest.fn();
+const mockPersistentVarsFindOne = jest.fn();
 jest.mock("../data/persistent-vars", () => ({
     groupDeviceVar: (...args) => mockGroupDeviceVar(...args),
     PersistentVars: () => ({
         save: mockPersistentVarsSave,
+        findOne: mockPersistentVarsFindOne,
     }),
 }));
 const mockNewKeys = jest.fn();
@@ -70,6 +74,13 @@ function mockDataContext() {
 // --- Tests ---
 beforeEach(() => {
     jest.clearAllMocks();
+    mockGetPkg.mockResolvedValue(undefined);
+    mockPersistentVarsFindOne.mockResolvedValue(undefined);
+    mockNewKeys.mockReturnValue({
+        publicKey: "test-public-key-abc",
+        secretKey: "test-secret-key-xyz",
+        publicBoxKey: "test-box-key",
+    });
 });
 describe("nameToFolderSlug", () => {
     it("converts a simple name", () => {
@@ -170,16 +181,18 @@ describe("createPackage", () => {
         expect(result.localPath).toBe("/packages/my-widget");
         expect(result.packageVersion).toBe(mockPv);
     });
-    it("delegates to installPackageFromBundles when directory already exists with valid package", async () => {
+    it("registers metadata, path, and signing key when importing an existing package directory", async () => {
         const deps = makeMockDeps({});
         const dc = mockDataContext();
-        // Location exists
+        const personalCtx = mockDataContext();
         deps.fs.exists.mockResolvedValue(true);
-        // getPackageInfo returns a valid packageId
         mockGetPackageInfo.mockResolvedValue({
             packageId: "00mnkoyo7mizav6tseubjzr3a",
             name: "existing-pkg",
+            description: "Imported package",
         });
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
         const mockPv = { packageVersionId: "pv002", packageId: "00mnkoyo7mizav6tseubjzr3a" };
         mockInstallPackageFromBundles.mockResolvedValue({
             packageVersion: mockPv,
@@ -187,16 +200,67 @@ describe("createPackage", () => {
             unchanged: false,
         });
         const result = await (0, package_creator_1.createPackage)(dc, deps, {
-            name: "existing-pkg",
+            name: "Existing Pkg",
             location: "/custom/path",
+            personalContext: personalCtx,
         });
-        // Should NOT clone
         expect(deps.shell.exec).not.toHaveBeenCalled();
-        // Should delegate to install
+        expect(mockGetPkg).toHaveBeenCalledWith("00mnkoyo7mizav6tseubjzr3a");
+        expect(mockNewKeys).toHaveBeenCalled();
+        expect(mockPersistentVarsSave).toHaveBeenCalledWith(expect.objectContaining({
+            name: "packageSigningKey_00mnkoyo7mizav6tseubjzr3a",
+            isSecret: true,
+            value: { value: "test-secret-key-xyz" },
+        }));
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            name: "Existing Pkg",
+            description: "Imported package",
+            publishPublicKey: "test-public-key-abc",
+        }), { restoreIfDeleted: true, saveAsSnapshot: true });
+        expect(mockGroupDeviceVar).toHaveBeenCalledWith("packageLocalPath_00mnkoyo7mizav6tseubjzr3a", expect.any(Object));
+        expect(pvarSetter).toHaveBeenCalledWith("/custom/path");
         expect(mockInstallPackageFromBundles).toHaveBeenCalledWith(dc, deps, "00mnkoyo7mizav6tseubjzr3a", { localPath: "/custom/path" });
         expect(result.packageId).toBe("00mnkoyo7mizav6tseubjzr3a");
         expect(result.localPath).toBe("/custom/path");
     });
+    it("reuses an existing publishPublicKey and does not rotate the signing key on re-import", async () => {
+        const deps = makeMockDeps({});
+        const dc = mockDataContext();
+        const personalCtx = mockDataContext();
+        deps.fs.exists.mockResolvedValue(true);
+        mockGetPackageInfo.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            name: "existing-pkg",
+        });
+        mockGetPkg.mockResolvedValue({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            name: "existing-pkg",
+            description: "Old description",
+            createdBy: "00m87fbwu96jzf8qnwllly0fd",
+            publishPublicKey: "already-established-public-key",
+            signature: "sig",
+            disabled: false,
+        });
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv002", packageId: "00mnkoyo7mizav6tseubjzr3a" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        await (0, package_creator_1.createPackage)(dc, deps, {
+            name: "existing-pkg",
+            location: "/custom/path",
+            personalContext: personalCtx,
+        });
+        expect(mockNewKeys).not.toHaveBeenCalled();
+        expect(mockPersistentVarsSave).not.toHaveBeenCalled();
+        expect(mockSignAndSavePkg).toHaveBeenCalledWith(expect.objectContaining({
+            publishPublicKey: "already-established-public-key",
+            createdBy: "00m87fbwu96jzf8qnwllly0fd",
+        }), expect.any(Object));
+    });
     it("throws when directory exists but has no valid package", async () => {
         const deps = makeMockDeps({});
         const dc = mockDataContext();
@@ -268,11 +332,6 @@ describe("createPackage", () => {
             loaded: undefined,
             unchanged: false,
         });
-        mockNewKeys.mockReturnValue({
-            publicKey: "test-public-key-abc",
-            secretKey: "test-secret-key-xyz",
-            publicBoxKey: "test-box-key",
-        });
         await (0, package_creator_1.createPackage)(dc, deps, {
             name: "Signed Pkg",
             personalContext: personalCtx,
@@ -319,6 +378,49 @@ describe("createPackage", () => {
         }), expect.any(Object));
     });
 });
+describe("ensurePackageSigningKey", () => {
+    it("generates a key once when none exists", async () => {
+        const personalCtx = mockDataContext();
+        const publicKey = await (0, package_creator_1.ensurePackageSigningKey)({
+            personalContext: personalCtx,
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            packageName: "Test Pkg",
+        });
+        expect(publicKey).toBe("test-public-key-abc");
+        expect(mockNewKeys).toHaveBeenCalledTimes(1);
+        expect(mockPersistentVarsSave).toHaveBeenCalledTimes(1);
+    });
+    it("reuses an established publishPublicKey without generating a new key", async () => {
+        const personalCtx = mockDataContext();
+        const publicKey = await (0, package_creator_1.ensurePackageSigningKey)({
+            personalContext: personalCtx,
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            packageName: "Test Pkg",
+            existingPublishPublicKey: "established-key",
+        });
+        expect(publicKey).toBe("established-key");
+        expect(mockNewKeys).not.toHaveBeenCalled();
+        expect(mockPersistentVarsSave).not.toHaveBeenCalled();
+    });
+    it("throws on an unrecoverable public/private key mismatch", async () => {
+        const { newKeys: realNewKeys } = jest.requireActual("../keys");
+        const realKeys = realNewKeys();
+        const otherKeys = realNewKeys();
+        const personalCtx = mockDataContext();
+        mockPersistentVarsFindOne.mockResolvedValue({
+            name: "packageSigningKey_00mnkoyo7mizav6tseubjzr3a",
+            value: { value: realKeys.secretKey },
+            isSecret: true,
+        });
+        await expect((0, package_creator_1.ensurePackageSigningKey)({
+            personalContext: personalCtx,
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            packageName: "Test Pkg",
+            existingPublishPublicKey: otherKeys.publicKey,
+        })).rejects.toThrow("signing key mismatch");
+        expect(mockNewKeys).not.toHaveBeenCalled();
+    });
+});
 describe("ensureTemplateCache", () => {
     it("clones template when cache directory does not exist", async () => {
         const deps = makeMockDeps({});

package/dist/rpc-types.d.ts

@@ -174,23 +174,6 @@ export declare const rpcServerCalls: {
         success: boolean;
         error?: string;
     }>;
-    voiceGetState: () => Promise<{
-        state: "disabled" | "idle" | "listening" | "recording" | "processing" | "speaking";
-        keyError?: "refused" | "invalid" | "limit" | "throttled";
-    }>;
-    voiceStartRecording: () => Promise<void>;
-    voiceStopRecording: () => Promise<void>;
-    voiceCancelRecording: () => Promise<void>;
-    voiceSetTargetChannel: (channelId: string) => Promise<void>;
-    voiceGetAudioDevices: () => Promise<string[]>;
-    voiceTestTTS: (text: string) => Promise<void>;
-    voiceNotifyPlaybackComplete: () => Promise<void>;
-    voiceStopPlayback: () => Promise<void>;
-    voiceGetThreadId: () => Promise<string | null>;
-    voiceSetThreadId: (threadId: string | null) => Promise<void>;
-    voiceNotifyTextActivity: () => Promise<void>;
-    voiceDisable: () => Promise<void>;
-    voiceEnable: () => Promise<void>;
     flushDatabases: () => Promise<void>;
     subscribeEvents: (names: string[]) => Promise<void>;
     unsubscribeEvents: (names: string[]) => Promise<void>;

package/dist/rpc-types.js

@@ -84,21 +84,6 @@ exports.rpcServerCalls = {
     uiClick: rpcStub("uiClick"),
     uiSet: rpcStub("uiSet"),
     uiScroll: rpcStub("uiScroll"),
-    // Voice control (settings managed via voiceSettings pvar, keys via secret pvars)
-    voiceGetState: rpcStub("voiceGetState"),
-    voiceStartRecording: rpcStub("voiceStartRecording"),
-    voiceStopRecording: rpcStub("voiceStopRecording"),
-    voiceCancelRecording: rpcStub("voiceCancelRecording"),
-    voiceSetTargetChannel: rpcStub("voiceSetTargetChannel"),
-    voiceGetAudioDevices: rpcStub("voiceGetAudioDevices"),
-    voiceTestTTS: rpcStub("voiceTestTTS"),
-    voiceNotifyPlaybackComplete: rpcStub("voiceNotifyPlaybackComplete"),
-    voiceStopPlayback: rpcStub("voiceStopPlayback"),
-    voiceGetThreadId: rpcStub("voiceGetThreadId"),
-    voiceSetThreadId: rpcStub("voiceSetThreadId"),
-    voiceNotifyTextActivity: rpcStub("voiceNotifyTextActivity"),
-    voiceDisable: rpcStub("voiceDisable"),
-    voiceEnable: rpcStub("voiceEnable"),
     // Flush all in-memory database snapshots to durable storage (IndexedDB in PWA).
     // No-op on Electron where better-sqlite3 writes are synchronous to disk.
     flushDatabases: (async () => { }),

package/package.json

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

package/dist/data/voice-messages.d.ts

@@ -1,33 +0,0 @@
-import { z } from "zod";
-import type { DataContext } from "../context/data-context";
-export declare const voiceMessageSchema: z.ZodObject<{
-    voiceMessageId: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
-    sessionId: z.ZodString;
-    role: z.ZodEnum<["user", "assistant"]>;
-    content: z.ZodString;
-    threadId: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodDefault<z.ZodDate>;
-}, "strip", z.ZodTypeAny, {
-    content: string;
-    role: "user" | "assistant";
-    sessionId: string;
-    createdAt: Date;
-    voiceMessageId: string;
-    threadId?: string | undefined;
-}, {
-    content: string;
-    role: "user" | "assistant";
-    sessionId: string;
-    createdAt?: Date | undefined;
-    voiceMessageId?: string | undefined;
-    threadId?: string | undefined;
-}>;
-export type IVoiceMessage = z.infer<typeof voiceMessageSchema>;
-export declare function VoiceMessages(dataContext?: DataContext): import("..").Table<{
-    content: string;
-    role: "user" | "assistant";
-    sessionId: string;
-    createdAt: Date;
-    voiceMessageId: string;
-    threadId?: string | undefined;
-}>;

package/dist/data/voice-messages.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.voiceMessageSchema = void 0;
-exports.VoiceMessages = VoiceMessages;
-const zod_1 = require("zod");
-const user_context_singleton_1 = require("../context/user-context-singleton");
-const zod_types_1 = require("../types/zod-types");
-const utils_1 = require("../utils");
-const table_definitions_system_1 = require("./orm/table-definitions.system");
-const types_1 = require("./orm/types");
-exports.voiceMessageSchema = zod_1.z.object({
-    voiceMessageId: zod_types_1.zodPeerId.default(() => (0, utils_1.newid)()),
-    sessionId: zod_1.z.string().describe("Groups messages belonging to one voice session"),
-    role: zod_1.z.enum(["user", "assistant"]),
-    content: zod_1.z.string(),
-    threadId: zod_1.z
-        .string()
-        .optional()
-        .describe("messageId of the channel thread created when an action was dispatched to the background agent"),
-    createdAt: zod_1.z.date().default(() => new Date()),
-});
-const metaData = {
-    name: "VoiceMessages",
-    description: "Voice conversation history for the self-contained voice assistant",
-    primaryKeyName: "voiceMessageId",
-    fields: (0, types_1.schemaToFields)(exports.voiceMessageSchema),
-    localOnly: true,
-    indexes: [{ fields: ["sessionId"] }, { fields: ["sessionId", "createdAt"] }],
-};
-(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.voiceMessageSchema);
-function VoiceMessages(dataContext) {
-    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.voiceMessageSchema);
-}