@peers-app/peers-sdk 0.23.8 → 0.23.10

package/dist/context/user-context-singleton.js

@@ -135,12 +135,27 @@ function getAllTables() {
     return tableMap;
 }
 if (!rpc_types_1.isClient) {
+    /**
+     * Resolve a table for a renderer RPC call.
+     *
+     * Prefers a full (code/package-registered) instance. When no package on this
+     * device has registered `tableName`, falls back to a synced
+     * `TableDefinitions` record so a renderer whose UI bundle is ahead of the
+     * package the host loaded can still reach the table's data.
+     */
     async function getTable(dataContextId, tableName) {
         const userContext = await getUserContext();
-        const table = userContext
-            .getDataContext(dataContextId || userContext.userId)
-            .tableContainer.getTable(tableName);
-        return table;
+        const tableContainer = userContext.getDataContext(dataContextId || userContext.userId).tableContainer;
+        try {
+            return tableContainer.getTable(tableName);
+        }
+        catch (err) {
+            const fallback = await tableContainer.getFallbackTable(tableName);
+            if (fallback) {
+                return fallback;
+            }
+            throw err;
+        }
     }
     // TODO: add check that client has permission to make this call
     rpc_types_1.rpcServerCalls.tableMethodCall = async (dataContextId, tableName, methodName, ...args) => {

package/dist/data/persistent-vars.d.ts

@@ -123,12 +123,20 @@ export declare function groupVar<T = string>(name: string, opts?: Omit<IPersiste
 /**
  * A persistent variable that is stored only on this device, in the user's personal db.
  * It can have a different value for each group on the device but is not synced to other devices.
+ *
+ * The record always lives in the personal db. `opts.dataContext` (or, when omitted, the
+ * current default group) only selects which group's value is addressed by suffixing the
+ * stored name with that data context id, so server-side callers that pin a group and
+ * renderer callers that follow the default group share one row.
  */
 export declare function groupDeviceVar<T = string>(name: string, opts: Omit<IPersistentVarOptionsWithDefault<T>, "scope">): PersistentVar<T>;
 export declare function groupDeviceVar<T = string>(name: string, opts?: Omit<IPersistentVarOptionsWithoutDefault<T>, "scope">): PersistentVar<T | undefined>;
 /**
  * A persistent variable that is stored in the user's personal db and synced across all their devices in the group.
  * It can have a different value for each user in the group and a different value for each group the user is in.
+ *
+ * As with {@link groupDeviceVar}, the record always lives in the personal db; `opts.dataContext`
+ * only selects the group whose value is addressed.
  */
 export declare function groupUserVar<T = string>(name: string, opts: Omit<IPersistentVarOptionsWithDefault<T>, "scope">): PersistentVar<T>;
 export declare function groupUserVar<T = string>(name: string, opts?: Omit<IPersistentVarOptionsWithoutDefault<T>, "scope">): PersistentVar<T | undefined>;

package/dist/data/persistent-vars.js

@@ -277,26 +277,71 @@ function persistentVarFactory(name, opts) {
         void (async () => {
             try {
                 const userContext = opts?.userContext || (await (0, user_context_singleton_1.getUserContext)());
-                function getDataContext() {
-                    if (opts?.dataContext) {
-                        return opts.dataContext;
-                    }
+                /**
+                 * The data context whose `PersistentVars` table stores this variable.
+                 *
+                 * Only `group` scope lives in a group DB. Every other scope lives in the
+                 * user's personal DB; for `groupDevice` / `groupUser` the route context
+                 * (`opts.dataContext` or the current default group) only disambiguates
+                 * the stored name (see {@link getVarNameInDb}). Storing the record in
+                 * the personal DB regardless of whether a caller pinned a `dataContext`
+                 * keeps server-side callers (which pin) and renderer callers (which
+                 * don't) reading and writing the same row.
+                 */
+                function getStorageDataContext() {
                     if (scope === "group") {
-                        return userContext.defaultDataContext();
+                        return opts?.dataContext ?? userContext.defaultDataContext();
+                    }
+                    return userContext.userDataContext;
+                }
+                /**
+                 * Before storage was unified in the personal DB, a `groupDevice` /
+                 * `groupUser` var created with an explicit group `dataContext` was
+                 * written to that group's DB. Return that legacy location so an
+                 * existing value can be migrated forward, or `undefined` when there is
+                 * no distinct legacy location for this variable.
+                 */
+                function getLegacyStorageDataContext() {
+                    if (scope !== "groupDevice" && scope !== "groupUser") {
+                        return undefined;
                     }
-                    else {
-                        return userContext.userDataContext;
+                    const pinned = opts?.dataContext;
+                    if (!pinned || pinned.dataContextId === userContext.userDataContext.dataContextId) {
+                        return undefined;
                     }
+                    return pinned;
                 }
                 function getVarNameInDb() {
                     const dc = opts?.dataContext || userContext.defaultDataContext();
                     return (0, persistent_var_identity_1.persistentVarStorageName)(name, scope, dc?.dataContextId);
                 }
+                /**
+                 * Copy a record left in a group DB by the pre-unification storage rule
+                 * into the personal DB. Secrets are skipped because their ciphertext is
+                 * bound to the group key and cannot be moved verbatim. The legacy row is
+                 * left in place: older builds on other devices may still read it, and
+                 * the personal copy is authoritative from here on.
+                 */
+                async function migrateLegacyRec(table, name) {
+                    const legacyContext = getLegacyStorageDataContext();
+                    if (!legacyContext) {
+                        return undefined;
+                    }
+                    const legacyRec = await PersistentVars(legacyContext).findOne({ name });
+                    if (!legacyRec || legacyRec.scope !== scope || legacyRec.isSecret) {
+                        return undefined;
+                    }
+                    const { persistentVarId: _legacyId, ...rest } = legacyRec;
+                    return table.save({ ...rest, persistentVarId: "" }, { weakInsert: true });
+                }
                 async function loadRecFromDb() {
-                    const dc = getDataContext();
+                    const dc = getStorageDataContext();
                     const table = PersistentVars(dc);
                     const name = getVarNameInDb();
                     let dbRec = await table.findOne({ name });
+                    if (!dbRec) {
+                        dbRec = await migrateLegacyRec(table, name);
+                    }
                     if (dbRec) {
                         if (dbRec.scope !== scope) {
                             console.warn(`${name}: deleting old persistent var record because scopes don't match.  If this is unexpected there could be two different persistent variables using the same name`);
@@ -340,7 +385,7 @@ function persistentVarFactory(name, opts) {
                         return;
                     }
                     rec.value.value = value;
-                    const dc = getDataContext();
+                    const dc = getStorageDataContext();
                     const table = PersistentVars(dc);
                     try {
                         rec = await table.save(rec, { weakInsert: true });
@@ -362,7 +407,7 @@ function persistentVarFactory(name, opts) {
                     }
                 }
                 deleteVarImpl = async () => {
-                    const dc = getDataContext();
+                    const dc = getStorageDataContext();
                     const table = PersistentVars(dc);
                     if (rec?.persistentVarId) {
                         await table.delete(rec);
@@ -374,7 +419,7 @@ function persistentVarFactory(name, opts) {
                 };
                 // subscribe to db changes
                 userContext.subscribeToDataChangedAcrossAllGroups(exports.persistentVarsMetaData.name, async (evt) => {
-                    const dc = getDataContext();
+                    const dc = getStorageDataContext();
                     if (dc && evt.dataContext && evt.dataContext.dataContextId !== dc.dataContextId) {
                         return;
                     }

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

@@ -50,8 +50,8 @@ export declare const toolAccessApprovalSchema: z.ZodObject<{
     userId: string;
     expiresAt: Date;
     toolId: string;
-    createdAt: Date;
     dataContextId: string;
+    createdAt: Date;
     toolAccessApprovalId: string;
     toolName: string;
     argsHash: string;
@@ -106,8 +106,8 @@ export declare function ToolAccessApprovals(dataContext?: DataContext): import("
     userId: string;
     expiresAt: Date;
     toolId: string;
-    createdAt: Date;
     dataContextId: string;
+    createdAt: Date;
     toolAccessApprovalId: string;
     toolName: string;
     argsHash: string;

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

@@ -1,17 +1,29 @@
 import type { DataContext } from "../context/data-context";
-import type { ICreatePackageOpts, ICreatePackageResult, IPackageInstallerDeps } from "./types";
+import type { IAddOrUpdatePackageResult, ICreatePackageOpts, ICreatePackageResult, IPackageInstallerDeps, ITemplateCacheResult, TemplateCacheRefreshFailure } from "./types";
+/**
+ * Normalize `addOrUpdatePackage` RPC results.
+ * Older hosts return a bare packageId string; current hosts return
+ * {@link IAddOrUpdatePackageResult}.
+ */
+export declare function unwrapAddOrUpdatePackageResult(result: string | IAddOrUpdatePackageResult): IAddOrUpdatePackageResult;
 /**
  * Convert a human-readable package name to a filesystem-safe folder slug.
  * "My Widget" → "my-widget", "camelCase Thing" → "camel-case-thing"
  */
 export declare function nameToFolderSlug(name: string): string;
+/**
+ * Classify a failed `git pull` of the template cache as a network outage versus
+ * a local/git problem (dirty tree, auth, merge conflict).
+ */
+export declare function classifyTemplatePullFailure(error: unknown): TemplateCacheRefreshFailure;
 /**
  * Ensure the package template is available locally.
  * On first call, clones the template repo into a dot-prefixed cache directory.
- * On subsequent calls, attempts a `git pull` to refresh (continues silently if offline).
- * @returns The path to the cached template directory.
+ * On later calls, attempts `git pull`. A failed pull does not block create;
+ * the existing cache is used and a warning is returned so the host can show it.
+ * @returns Cache path and an optional stale-template warning.
  */
-export declare function ensureTemplateCache(deps: IPackageInstallerDeps, templateRepo: string): Promise<string>;
+export declare function ensureTemplateCache(deps: IPackageInstallerDeps, templateRepo: string): Promise<ITemplateCacheResult>;
 /**
  * Resolve (or create) the Ed25519 publish public key for a package.
  *

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapAddOrUpdatePackageResult = unwrapAddOrUpdatePackageResult;
 exports.nameToFolderSlug = nameToFolderSlug;
+exports.classifyTemplatePullFailure = classifyTemplatePullFailure;
 exports.ensureTemplateCache = ensureTemplateCache;
 exports.ensurePackageSigningKey = ensurePackageSigningKey;
 exports.importExistingPackage = importExistingPackage;
@@ -22,6 +24,17 @@ function patchTemplateTokens(contents, values) {
         .replaceAll("<app-screen-id>", values.appScreenId)
         .replaceAll("<contract-id>", values.contractId);
 }
+/**
+ * Normalize `addOrUpdatePackage` RPC results.
+ * Older hosts return a bare packageId string; current hosts return
+ * {@link IAddOrUpdatePackageResult}.
+ */
+function unwrapAddOrUpdatePackageResult(result) {
+    if (typeof result === "string") {
+        return { packageId: result };
+    }
+    return result;
+}
 /**
  * Convert a human-readable package name to a filesystem-safe folder slug.
  * "My Widget" → "my-widget", "camelCase Thing" → "camel-case-thing"
@@ -31,26 +44,67 @@ function nameToFolderSlug(name) {
     slug = slug.replace(/\s+/g, " ").trim();
     return (0, utils_1.camelCaseToHyphens)(slug);
 }
+const OFFLINE_PULL_PATTERN = /unable to access|could not resolve host|failed to connect|connection (refused|timed out|reset)|network is unreachable|enotfound|etimedout|eai_again|offline|ssl connect error|could not fetch/i;
+/**
+ * Classify a failed `git pull` of the template cache as a network outage versus
+ * a local/git problem (dirty tree, auth, merge conflict).
+ */
+function classifyTemplatePullFailure(error) {
+    const text = execErrorText(error);
+    return OFFLINE_PULL_PATTERN.test(text) ? "offline" : "could-not-refresh";
+}
+function execErrorText(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const extra = "stderr" in error && typeof error.stderr === "string" ? error.stderr : "";
+    return [error.message, extra].filter(Boolean).join("\n");
+}
+function firstUsefulErrorLine(text) {
+    const line = text
+        .split(/\r?\n/)
+        .map((entry) => entry.trim())
+        .find((entry) => entry.length > 0);
+    if (!line) {
+        return "";
+    }
+    return line.length > 240 ? `${line.slice(0, 237)}...` : line;
+}
+function templateCacheWarning(failure, error) {
+    const detail = firstUsefulErrorLine(execErrorText(error));
+    const detailSuffix = detail ? ` ${detail}` : "";
+    if (failure === "offline") {
+        return ("This package was created from a cached template because the template repository could not be reached (offline or network error). It may not match the latest isolate package scaffold." +
+            detailSuffix);
+    }
+    return ("This package was created from a cached template because git pull could not update ~/peers/packages/.peers-package-template. It may be a stale version. Local changes in that cache directory are the usual cause." +
+        detailSuffix);
+}
 /**
  * Ensure the package template is available locally.
  * On first call, clones the template repo into a dot-prefixed cache directory.
- * On subsequent calls, attempts a `git pull` to refresh (continues silently if offline).
- * @returns The path to the cached template directory.
+ * On later calls, attempts `git pull`. A failed pull does not block create;
+ * the existing cache is used and a warning is returned so the host can show it.
+ * @returns Cache path and an optional stale-template warning.
  */
 async function ensureTemplateCache(deps, templateRepo) {
     const cachePath = deps.resolvePath(deps.packagesRootDir, TEMPLATE_CACHE_DIR);
     if (await deps.fs.exists(cachePath)) {
         try {
             await deps.shell.exec("git pull", { cwd: cachePath });
+            return { cachePath };
         }
-        catch {
-            // Offline or remote unreachable — continue with stale cache
+        catch (error) {
+            const refreshFailure = classifyTemplatePullFailure(error);
+            return {
+                cachePath,
+                refreshFailure,
+                warning: templateCacheWarning(refreshFailure, error),
+            };
         }
     }
-    else {
-        await deps.shell.exec(`git clone ${templateRepo} ${cachePath}`);
-    }
-    return cachePath;
+    await deps.shell.exec(`git clone ${templateRepo} ${cachePath}`);
+    return { cachePath };
 }
 /**
  * Resolve (or create) the Ed25519 publish public key for a package.
@@ -202,6 +256,7 @@ async function createPackage(dataContext, deps, opts) {
     const contractId = (0, utils_1.newid)();
     const appScreenId = (0, utils_1.newid)();
     const templateRepo = opts.templateRepo ?? DEFAULT_TEMPLATE_REPO;
+    let templateWarning;
     // Get template contents into location
     if (opts.templateRepo && opts.templateRepo !== DEFAULT_TEMPLATE_REPO) {
         // Custom template — clone directly (no caching)
@@ -209,8 +264,9 @@ async function createPackage(dataContext, deps, opts) {
     }
     else {
         // Default template — use local cache for speed and offline support
-        const cachePath = await ensureTemplateCache(deps, templateRepo);
-        await deps.shell.exec(`cp -r ${cachePath}/. ${location}`);
+        const templateCache = await ensureTemplateCache(deps, templateRepo);
+        templateWarning = templateCache.warning;
+        await deps.shell.exec(`cp -r ${templateCache.cachePath}/. ${location}`);
     }
     // Patch package.json
     const packageJsonPath = deps.resolvePath(location, "package.json");
@@ -273,5 +329,6 @@ async function createPackage(dataContext, deps, opts) {
         packageId,
         localPath: location,
         packageVersion: result.packageVersion,
+        templateWarning,
     };
 }

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

@@ -83,6 +83,22 @@ beforeEach(() => {
         publicBoxKey: "test-box-key",
     });
 });
+describe("unwrapAddOrUpdatePackageResult", () => {
+    it("accepts a legacy packageId string", () => {
+        expect((0, package_creator_1.unwrapAddOrUpdatePackageResult)("00mnkoyo7mizav6tseubjzr3a")).toEqual({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+        });
+    });
+    it("passes through a structured result including a template warning", () => {
+        expect((0, package_creator_1.unwrapAddOrUpdatePackageResult)({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            warning: "stale template",
+        })).toEqual({
+            packageId: "00mnkoyo7mizav6tseubjzr3a",
+            warning: "stale template",
+        });
+    });
+});
 describe("nameToFolderSlug", () => {
     it("converts a simple name", () => {
         expect((0, package_creator_1.nameToFolderSlug)("My Widget")).toBe("my-widget");
@@ -201,6 +217,37 @@ describe("createPackage", () => {
         });
         expect(result.localPath).toBe("/packages/my-widget");
         expect(result.packageVersion).toBe(mockPv);
+        expect(result.templateWarning).toBeUndefined();
+    });
+    it("returns a stale-template warning when the cached template cannot be refreshed", async () => {
+        const shellExec = jest.fn(async (cmd) => {
+            if (cmd === "git pull") {
+                throw new Error("error: Your local changes to the following files would be overwritten by merge:\n\t.gitignore");
+            }
+            return { stdout: "", stderr: "" };
+        });
+        const deps = makeMockDeps({}, shellExec);
+        const dc = mockDataContext();
+        deps.fs.exists.mockImplementation(async (path) => {
+            if (path === "/packages/desk")
+                return false;
+            if (path === "/packages/.peers-package-template")
+                return true;
+            return false;
+        });
+        deps.fs.readJson.mockResolvedValue({ name: "template", peers: {} });
+        const pvarSetter = jest.fn();
+        mockGroupDeviceVar.mockReturnValue(pvarSetter);
+        mockInstallPackageFromBundles.mockResolvedValue({
+            packageVersion: { packageVersionId: "pv" },
+            loaded: undefined,
+            unchanged: false,
+        });
+        const result = await (0, package_creator_1.createPackage)(dc, deps, { name: "Desk" });
+        expect(result.templateWarning).toMatch(/stale version/i);
+        expect(result.templateWarning).toMatch(/local changes/i);
+        expect(result.localPath).toBe("/packages/desk");
+        expect(deps.shell.exec).toHaveBeenCalledWith("cp -r /packages/.peers-package-template/. /packages/desk");
     });
     it("registers metadata, path, and signing key when importing an existing package directory", async () => {
         const deps = makeMockDeps({});
@@ -447,14 +494,16 @@ describe("ensureTemplateCache", () => {
         const deps = makeMockDeps({});
         deps.fs.exists.mockResolvedValue(false);
         const result = await (0, package_creator_1.ensureTemplateCache)(deps, "https://github.com/peers-app/peers-package-template.git");
-        expect(result).toBe("/packages/.peers-package-template");
+        expect(result.cachePath).toBe("/packages/.peers-package-template");
+        expect(result.warning).toBeUndefined();
         expect(deps.shell.exec).toHaveBeenCalledWith("git clone https://github.com/peers-app/peers-package-template.git /packages/.peers-package-template");
     });
     it("pulls latest when cache directory already exists", async () => {
         const deps = makeMockDeps({});
         deps.fs.exists.mockResolvedValue(true);
         const result = await (0, package_creator_1.ensureTemplateCache)(deps, "https://github.com/peers-app/peers-package-template.git");
-        expect(result).toBe("/packages/.peers-package-template");
+        expect(result.cachePath).toBe("/packages/.peers-package-template");
+        expect(result.warning).toBeUndefined();
         expect(deps.shell.exec).toHaveBeenCalledWith("git pull", {
             cwd: "/packages/.peers-package-template",
         });
@@ -462,16 +511,43 @@ describe("ensureTemplateCache", () => {
         const execCalls = deps.shell.exec.mock.calls.map((c) => c[0]);
         expect(execCalls).not.toContain(expect.stringContaining("git clone"));
     });
-    it("continues silently when pull fails (offline)", async () => {
+    it("returns an offline warning when pull cannot reach the remote", async () => {
+        const shellExec = jest.fn(async (cmd) => {
+            if (cmd === "git pull") {
+                throw new Error("fatal: unable to access 'https://github.com/peers-app/peers-package-template.git'");
+            }
+            return { stdout: "", stderr: "" };
+        });
+        const deps = makeMockDeps({}, shellExec);
+        deps.fs.exists.mockResolvedValue(true);
+        const result = await (0, package_creator_1.ensureTemplateCache)(deps, "https://github.com/peers-app/peers-package-template.git");
+        expect(result.cachePath).toBe("/packages/.peers-package-template");
+        expect(result.refreshFailure).toBe("offline");
+        expect(result.warning).toMatch(/could not be reached/i);
+    });
+    it("returns a could-not-refresh warning when pull fails for local git reasons", async () => {
         const shellExec = jest.fn(async (cmd) => {
-            if (cmd === "git pull")
-                throw new Error("fatal: unable to access remote");
+            if (cmd === "git pull") {
+                throw new Error("error: Your local changes to the following files would be overwritten by merge:\n\t.gitignore");
+            }
             return { stdout: "", stderr: "" };
         });
         const deps = makeMockDeps({}, shellExec);
         deps.fs.exists.mockResolvedValue(true);
         const result = await (0, package_creator_1.ensureTemplateCache)(deps, "https://github.com/peers-app/peers-package-template.git");
-        // Should not throw, returns cache path
-        expect(result).toBe("/packages/.peers-package-template");
+        expect(result.cachePath).toBe("/packages/.peers-package-template");
+        expect(result.refreshFailure).toBe("could-not-refresh");
+        expect(result.warning).toMatch(/stale version/i);
+        expect(result.warning).toMatch(/overwritten by merge/i);
+    });
+});
+describe("classifyTemplatePullFailure", () => {
+    it("treats unreachable remotes as offline", () => {
+        expect((0, package_creator_1.classifyTemplatePullFailure)(new Error("fatal: unable to access remote"))).toBe("offline");
+        expect((0, package_creator_1.classifyTemplatePullFailure)(new Error("Could not resolve host: github.com"))).toBe("offline");
+    });
+    it("treats dirty trees and auth problems as could-not-refresh", () => {
+        expect((0, package_creator_1.classifyTemplatePullFailure)(new Error("Your local changes to the following files would be overwritten by merge"))).toBe("could-not-refresh");
+        expect((0, package_creator_1.classifyTemplatePullFailure)(new Error("Permission denied (publickey)"))).toBe("could-not-refresh");
     });
 });

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

@@ -84,11 +84,40 @@ export interface ICreatePackageOpts {
      */
     personalContext?: import("../context/data-context").DataContext;
 }
+/** Why a `git pull` of the cached package template did not succeed. */
+export type TemplateCacheRefreshFailure = "offline" | "could-not-refresh";
+/** Local template cache path plus a non-fatal refresh warning when present. */
+export interface ITemplateCacheResult {
+    /** Directory copied from when scaffolding a new package. */
+    cachePath: string;
+    /** Set when `git pull` failed and the existing cache was used anyway. */
+    refreshFailure?: TemplateCacheRefreshFailure;
+    /** User-facing explanation when {@link refreshFailure} is set. */
+    warning?: string;
+}
 /** Result of {@link createPackage}. */
 export interface ICreatePackageResult {
+    /** New or imported package ID. */
     packageId: string;
+    /** On-disk package directory. */
     localPath: string;
+    /** Installed local/dev package version record. */
     packageVersion: IPackageVersion;
+    /**
+     * Present when the default template cache could not be refreshed and a
+     * possibly stale copy was used. Creation still succeeded.
+     */
+    templateWarning?: string;
+}
+/** Host/RPC result for adding, creating, or updating a package. */
+export interface IAddOrUpdatePackageResult {
+    /** Package that was created, imported, cloned, or updated. */
+    packageId: string;
+    /**
+     * Non-fatal notice after a successful local create (for example a stale
+     * template cache). Undefined on update, clone, and import of an existing directory.
+     */
+    warning?: string;
 }
 /** Options for {@link clonePackage}. */
 export interface IClonePackageOpts {
@@ -103,8 +132,12 @@ export interface IClonePackageOpts {
 }
 /** Result of {@link clonePackage}. */
 export interface IClonePackageResult {
+    /** Imported package ID from the cloned repo. */
     packageId: string;
+    /** On-disk clone directory. */
     localPath: string;
+    /** Git URL that was cloned. */
     remoteRepo: string;
+    /** Installed local/dev package version record. */
     packageVersion: IPackageVersion;
 }

package/dist/rpc-types.d.ts

@@ -2,6 +2,7 @@ import type { IDeviceDatabaseQueryResult, IDeviceOperationStatus, IDeviceToolRun
 import type { ITool } from "./data/tools";
 import type { DevicePairingCeremonyAction, DevicePairingStartDestinationInput, DevicePairingStartSourceResult, DevicePairingState } from "./device-pairing";
 import type { IConsoleLog } from "./logging/console-logs.table";
+import type { IAddOrUpdatePackageResult } from "./package-installer/types";
 import type { IAppNav } from "./types/app-nav";
 /** Named event payload sent across the frontend RPC bridge. */
 export interface IEventData<T = any> {
@@ -61,7 +62,7 @@ export declare const rpcServerCalls: {
         packageLocation?: string;
         update?: boolean;
         linkRemote?: boolean;
-    }) => Promise<string>;
+    }) => Promise<string | IAddOrUpdatePackageResult>;
     seedBundledPeersCore: (dataContextId?: string) => Promise<boolean>;
     setUserIdAndSecretKey: (userId: string, secretKey: string) => Promise<void>;
     getUserId: () => Promise<string | undefined>;

package/package.json

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