@peers-app/peers-sdk 0.7.0 → 0.7.2

package/dist/context/user-context.d.ts

@@ -11,9 +11,6 @@ export declare class UserContext {
     readonly currentlyActiveGroupId: Observable<string | undefined>;
     readonly packagesRootDir: Observable<string>;
     readonly reloadPackagesOnPageRefresh: Observable<boolean>;
-    readonly packageLocalPathsResolved: Observable<{
-        [packageId: string]: string;
-    }>;
     readonly groupIds: Observable<string[]>;
     readonly userDataContext: DataContext;
     readonly groupDataContexts: Map<string, DataContext>;

package/dist/context/user-context.js

@@ -16,7 +16,6 @@ class UserContext {
     currentlyActiveGroupId = (0, observable_1.observable)();
     packagesRootDir = (0, observable_1.observable)('');
     reloadPackagesOnPageRefresh = (0, observable_1.observable)(false);
-    packageLocalPathsResolved = (0, observable_1.observable)({});
     groupIds = (0, observable_1.observable)([]);
     userDataContext;
     groupDataContexts = new Map();
@@ -109,7 +108,7 @@ class UserContext {
      */
     async loadUserContextObservablesFromDB() {
         const persistentVars = await this.userDataContext.tableContainer.getTableByName(data_1.persistentVarsMetaData.name);
-        const vars = await persistentVars.list({ name: { $in: ['myUserId', 'thisDeviceId', 'currentlyActiveGroupId', 'packagesRootDir', 'reloadPackagesOnPageRefresh', 'packageLocalPathsResolved'] } });
+        const vars = await persistentVars.list({ name: { $in: ['myUserId', 'thisDeviceId', 'currentlyActiveGroupId', 'packagesRootDir', 'reloadPackagesOnPageRefresh'] } });
         const varDbValues = vars.reduce((acc, curr) => {
             acc[curr.name] = curr.value?.value;
             return acc;
@@ -127,14 +126,10 @@ class UserContext {
         const reloadPackagesOnPageRefreshPVar = (0, data_1.deviceVar)('reloadPackagesOnPageRefresh', { defaultValue: false, dbValue: varDbValues['reloadPackagesOnPageRefresh'], userContext: this });
         this.reloadPackagesOnPageRefresh(reloadPackagesOnPageRefreshPVar());
         (0, observable_1.linkObservables)(reloadPackagesOnPageRefreshPVar, this.reloadPackagesOnPageRefresh);
-        const packageLocalPathsResolvedPVar = (0, data_1.deviceVar)('packageLocalPathsResolved', { defaultValue: {}, dbValue: varDbValues['packageLocalPathsResolved'], userContext: this });
-        this.packageLocalPathsResolved(packageLocalPathsResolvedPVar());
-        (0, observable_1.linkObservables)(packageLocalPathsResolvedPVar, this.packageLocalPathsResolved);
         await Promise.all([
             deviceIdPVar.loadingPromise,
             packagesRootDirPVar.loadingPromise,
             reloadPackagesOnPageRefreshPVar.loadingPromise,
-            packageLocalPathsResolvedPVar.loadingPromise,
         ]);
     }
     async getMe() {

package/dist/data/files/files.d.ts

@@ -4,23 +4,25 @@ import { FileWriteStream } from "./file-write-stream";
 import { IFile, IFileInput } from "./file.types";
 import type { DataContext } from "../../context/data-context";
 export declare class FilesTable extends Table<IFile> {
-    /** @deprecated Direct inserts forbidden; use safeFile() or saveFileRecord() */
+    /** @deprecated Direct inserts forbidden; use saveFile() or saveFileRecord() */
     insert(..._args: Parameters<Table<any>['insert']>): never;
-    /** @deprecated Direct updates forbidden; use safeFile() or saveFileRecord() */
+    /** @deprecated Direct updates forbidden; use saveFile() or saveFileRecord() */
     update(..._args: Parameters<Table<any>['update']>): never;
     /** @deprecated Direct deletes forbidden; use deleteFile() */
     delete(..._args: Parameters<Table<any>['delete']>): never;
+    /** @deprecated Direct save forbidden; use saveFile() or saveFileRecord() */
+    save(..._args: Parameters<Table<any>['save']>): never;
     createWriteStream(metadata: IFileInput): Promise<FileWriteStream>;
     /**
-     * Note: Use `saveFile` instead for direct use. This method is intended for internal use
-     * to insert a file record into the database as part of streaming operations.
-     * @param fileRecord The file record to insert
+     * Note: Use `saveFile` to write a file to disk. This method is for managing
+     * the file metadata in the database which is done automatically by `saveFile`.
+     * @param fileRecord The file record to save to the database
      * @returns The inserted file record
      */
     saveFileRecord(fileRecord: IFile): Promise<IFile>;
     openReadStream(fileId: string, preloadChunksCount?: number): Promise<FileReadStream | null>;
     saveFile(metaData: IFileInput, data: Uint8Array | string): Promise<IFile>;
-    getFile(fileId: string): Promise<Uint8Array | null>;
+    getFileContents(fileId: string): Promise<Uint8Array | null>;
     deleteFile(fileId: string): Promise<void>;
     createIndexFileRecursively(chunkHashes: string[]): Promise<string>;
     loadChunkHashesRecursively(indexFileId: string): Promise<string[]>;

package/dist/data/files/files.js

@@ -11,25 +11,29 @@ const file_read_stream_1 = require("./file-read-stream");
 const file_write_stream_1 = require("./file-write-stream");
 const file_types_1 = require("./file.types");
 class FilesTable extends orm_1.Table {
-    /** @deprecated Direct inserts forbidden; use safeFile() or saveFileRecord() */
+    /** @deprecated Direct inserts forbidden; use saveFile() or saveFileRecord() */
     insert(..._args) {
-        throw new Error('Direct inserts forbidden; use safeFile() or saveFileRecord()');
+        throw new Error('Direct inserts forbidden; use saveFile() or saveFileRecord()');
     }
-    /** @deprecated Direct updates forbidden; use safeFile() or saveFileRecord() */
+    /** @deprecated Direct updates forbidden; use saveFile() or saveFileRecord() */
     update(..._args) {
-        throw new Error('Direct updates forbidden; use safeFile() or saveFileRecord()');
+        throw new Error('Direct updates forbidden; use saveFile() or saveFileRecord()');
     }
     /** @deprecated Direct deletes forbidden; use deleteFile() */
     delete(..._args) {
         throw new Error('Direct deletes forbidden; use deleteFile()');
     }
+    /** @deprecated Direct save forbidden; use saveFile() or saveFileRecord() */
+    save(..._args) {
+        throw new Error('Direct saves forbidden; use saveFile() or saveFileRecord()');
+    }
     async createWriteStream(metadata) {
         return new file_write_stream_1.FileWriteStream(metadata, this);
     }
     /**
-     * Note: Use `saveFile` instead for direct use. This method is intended for internal use
-     * to insert a file record into the database as part of streaming operations.
-     * @param fileRecord The file record to insert
+     * Note: Use `saveFile` to write a file to disk. This method is for managing
+     * the file metadata in the database which is done automatically by `saveFile`.
+     * @param fileRecord The file record to save to the database
      * @returns The inserted file record
      */
     async saveFileRecord(fileRecord) {
@@ -56,7 +60,7 @@ class FilesTable extends orm_1.Table {
         // Finalize and return the result
         return await writeStream.finalize();
     }
-    async getFile(fileId) {
+    async getFileContents(fileId) {
         // Use FileReadStream internally to ensure consistent chunk reading logic
         const readStream = await this.openReadStream(fileId);
         if (!readStream) {
@@ -76,9 +80,9 @@ class FilesTable extends orm_1.Table {
             await this.deleteFile(fileRecord.indexFileId);
         }
         // Note: We don't delete chunks since they may be shared with other files
-        // Chunk cleanup could be implemented as a separate garbage collection process
+        // TODO Chunk cleanup needs to be implemented as a separate garbage collection process
         // that removes chunks not referenced by any files
-        // Delete from database
+        // Delete file record from database
         await super.delete(fileId);
     }
     // Create an index file recursively for large files
@@ -103,7 +107,7 @@ class FilesTable extends orm_1.Table {
     // Load chunk hashes recursively from an index file
     async loadChunkHashesRecursively(indexFileId) {
         // Recursively load the index file
-        const indexBuffer = await this.getFile(indexFileId);
+        const indexBuffer = await this.getFileContents(indexFileId);
         if (!indexBuffer) {
             throw new Error(`Index file not found: ${indexFileId}`);
         }
@@ -119,7 +123,7 @@ function Files(dataContext) {
 }
 // TODO implement permissions check for file access
 rpc_types_1.rpcServerCalls.getFileContents = async (fileId, encoding = 'utf8') => {
-    const data = await Files().getFile(fileId);
+    const data = await Files().getFileContents(fileId);
     if (data === null) {
         throw new Error(`File not found: ${fileId}`);
     }

package/dist/data/files/files.test.js

@@ -179,7 +179,7 @@ describe('FileTable', () => {
             // Save file first
             await fileTable.saveFile(metadata, originalData);
             // Retrieve file
-            const retrievedData = await fileTable.getFile(fileId);
+            const retrievedData = await fileTable.getFileContents(fileId);
             expect(new Uint8Array(retrievedData)).toEqual(originalData);
         });
         it('should retrieve a multi-chunk file', async () => {
@@ -194,11 +194,11 @@ describe('FileTable', () => {
             // Save file first
             await fileTable.saveFile(metadata, originalData);
             // Retrieve file
-            const retrievedData = await fileTable.getFile(fileId);
+            const retrievedData = await fileTable.getFileContents(fileId);
             expect(new Uint8Array(retrievedData)).toEqual(originalData);
         });
         it('should return null for non-existent file', async () => {
-            const result = await fileTable.getFile('non-existent');
+            const result = await fileTable.getFileContents('non-existent');
             expect(result).toBeNull();
         });
         it('should return null when chunk is missing', async () => {
@@ -212,11 +212,11 @@ describe('FileTable', () => {
             };
             // Insert metadata directly without saving chunks
             await fileTable.dataSource.insert(metadata);
-            const result = await fileTable.getFile(fileId);
+            const result = await fileTable.getFileContents(fileId);
             expect(result).toBeNull();
         });
         it('should return null when chunk is missing during read', async () => {
-            const result = await fileTable.getFile('non-existent');
+            const result = await fileTable.getFileContents('non-existent');
             expect(result).toBeNull();
         });
     });
@@ -233,14 +233,14 @@ describe('FileTable', () => {
             // Save file first
             const saved = await fileTable.saveFile(metadata, data);
             // Verify file exists
-            const fileData = await fileTable.getFile(fileId);
+            const fileData = await fileTable.getFileContents(fileId);
             expect(new Uint8Array(fileData)).toEqual(data);
             const chunkHash = saved.chunkHashes[0];
             expect(await mockFileOps.fileExists(`file_chunks/${chunkHash}`)).toBe(true);
             // Delete file
             await fileTable.deleteFile(fileId);
             // Verify file metadata is gone but chunk remains (for potential sharing)
-            expect(await fileTable.getFile(fileId)).toBeNull();
+            expect(await fileTable.getFileContents(fileId)).toBeNull();
             expect(await mockFileOps.fileExists(`file_chunks/${chunkHash}`)).toBe(true);
         });
         it('should handle deleting non-existent file gracefully', async () => {
@@ -266,7 +266,7 @@ describe('FileTable', () => {
             // Delete file
             await fileTable.deleteFile(fileId);
             // Verify file metadata is gone but chunks remain (for potential sharing)
-            expect(await fileTable.getFile(fileId)).toBeNull();
+            expect(await fileTable.getFileContents(fileId)).toBeNull();
             expect(await mockFileOps.fileExists(`file_chunks/${chunk0Hash}`)).toBe(true);
             expect(await mockFileOps.fileExists(`file_chunks/${chunk1Hash}`)).toBe(true);
         });
@@ -300,8 +300,8 @@ describe('FileTable', () => {
             expect(await mockFileOps.fileExists(chunkPath)).toBe(true);
             expect(mockFileOps.getStoredFiles().filter(path => path.includes(chunkHash))).toHaveLength(1);
             // Both files should retrieve the same content
-            const file1Data = await fileTable.getFile(fileId1);
-            const file2Data = await fileTable.getFile(fileId2);
+            const file1Data = await fileTable.getFileContents(fileId1);
+            const file2Data = await fileTable.getFileContents(fileId2);
             expect(new Uint8Array(file1Data)).toEqual(data);
             expect(new Uint8Array(file2Data)).toEqual(data);
         });
@@ -324,7 +324,7 @@ describe('FileTable', () => {
             expect(result.chunkHashes).toHaveLength(1);
             expect(result.indexFileId).toBeUndefined();
             // Should be able to retrieve the file
-            const retrievedData = await fileTable.getFile(fileId);
+            const retrievedData = await fileTable.getFileContents(fileId);
             expect(new Uint8Array(retrievedData)).toEqual(smallData);
         });
         it('should use recursive index files for very large files', async () => {
@@ -347,7 +347,7 @@ describe('FileTable', () => {
                 expect(result.chunkHashes).toBeUndefined();
                 expect(result.indexFileId).toBeTruthy();
                 // Should be able to retrieve the file
-                const retrievedData = await fileTable.getFile(fileId);
+                const retrievedData = await fileTable.getFileContents(fileId);
                 expect(retrievedData).toBeTruthy();
                 expect(new Uint8Array(retrievedData)).toEqual(largeData);
                 // The index file should be marked as an index file
@@ -374,7 +374,7 @@ describe('FileTable', () => {
             };
             // Insert metadata directly without creating index file
             await fileTable.dataSource.insert(metadata);
-            await expect(fileTable.getFile(fileId)).rejects.toThrow('Index file not found: missing_index_file_id');
+            await expect(fileTable.getFileContents(fileId)).rejects.toThrow('Index file not found: missing_index_file_id');
         });
     });
     describe('Streaming API', () => {
@@ -399,7 +399,7 @@ describe('FileTable', () => {
                 expect(result.fileSize).toBe(23); // Total bytes written: 'Hello, streaming world!'
                 expect(result.chunkHashes).toHaveLength(1); // Small file, single chunk
                 // Verify we can read the file back
-                const retrievedData = await fileTable.getFile(fileId);
+                const retrievedData = await fileTable.getFileContents(fileId);
                 expect(Buffer.from(retrievedData).toString('utf8')).toBe('Hello, streaming world!');
             });
             it('should handle large file streaming across multiple chunks', async () => {
@@ -421,7 +421,7 @@ describe('FileTable', () => {
                 expect(result.fileSize).toBe(chunkSize + 500);
                 expect(result.chunkHashes).toHaveLength(2); // Two chunks
                 // Verify content
-                const retrievedData = await fileTable.getFile(fileId);
+                const retrievedData = await fileTable.getFileContents(fileId);
                 expect(retrievedData?.length).toBe(chunkSize + 500);
                 expect(new Uint8Array(retrievedData).subarray(0, chunkSize).every(b => b === 65)).toBe(true); // All 'A's
                 expect(new Uint8Array(retrievedData).subarray(chunkSize).every(b => b === 66)).toBe(true); // All 'B's
@@ -490,7 +490,7 @@ describe('FileTable', () => {
                 expect(result.fileSize).toBe(data.length);
                 expect(result.chunkHashes).toHaveLength(3); // 2 complete + 1 partial chunk
                 // Verify we can read it back correctly
-                const retrievedData = await fileTable.getFile(fileId);
+                const retrievedData = await fileTable.getFileContents(fileId);
                 expect(retrievedData?.length).toBe(data.length);
                 expect(new Uint8Array(retrievedData)).toEqual(data);
             });
@@ -686,7 +686,7 @@ describe('FileTable', () => {
                 await fileTable.dataSource.insert(metadata);
                 // This should return null when the chunk can't be found
                 // instead of throwing an error or hanging
-                const result = await fileTable.getFile(fileId);
+                const result = await fileTable.getFileContents(fileId);
                 expect(result).toBeNull();
             });
         });

package/dist/data/index.d.ts

@@ -18,6 +18,7 @@ export * from "./knowledge/peer-types";
 export * from "./knowledge/predicates";
 export * from "./messages";
 export * from "./packages";
+export * from "./packages.utils";
 export * from "./peer-events/peer-event-handlers";
 export * from "./peer-events/peer-event-types";
 export * from "./peer-events/peer-events";

package/dist/data/index.js

@@ -34,6 +34,7 @@ __exportStar(require("./knowledge/peer-types"), exports);
 __exportStar(require("./knowledge/predicates"), exports);
 __exportStar(require("./messages"), exports);
 __exportStar(require("./packages"), exports);
+__exportStar(require("./packages.utils"), exports);
 __exportStar(require("./peer-events/peer-event-handlers"), exports);
 __exportStar(require("./peer-events/peer-event-types"), exports);
 __exportStar(require("./peer-events/peer-events"), exports);

package/dist/data/orm/table.js

@@ -144,11 +144,9 @@ class Table {
         this.setLocalOperation(recordId, operation);
         let result;
         try {
-            // if (isInsert) {
-            //   result = await this.dataSource.insert(record);
-            // } else {
-            //   result = await this.dataSource.update(record);
-            // }
+            // NOTE: done this way to allow individual tables to have custom logic in `save`, `insert`, and `update`
+            //       but this results in a double-read (this method and the data-source method).  
+            // TODO: try to avoid the double-read, probably by passing the just-read result as `opts.dbData`
             result = await this.dataSource.save(record, opts);
         }
         finally {

package/dist/data/packages.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.reloadPackagesOnPageRefresh = exports.packagesRootDir = exports.PackagesTable = void 0;
 exports.Packages = Packages;
 const zod_1 = require("zod");
-const app_nav_1 = require("../types/app-nav");
-const types_1 = require("./orm/types");
-const persistent_vars_1 = require("./persistent-vars");
-const table_definitions_system_1 = require("./orm/table-definitions.system");
 const context_1 = require("../context");
+const app_nav_1 = require("../types/app-nav");
 const orm_1 = require("./orm");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const types_1 = require("./orm/types");
 const package_permissions_1 = require("./package-permissions");
+const persistent_vars_1 = require("./persistent-vars");
 const schema = zod_1.z.object({
     packageId: zod_1.z.string(),
     name: zod_1.z.string(),
@@ -87,4 +87,3 @@ function Packages(dataContext) {
 }
 exports.packagesRootDir = (0, persistent_vars_1.deviceVar)('packagesRootDir', { defaultValue: '~/peers-packages' });
 exports.reloadPackagesOnPageRefresh = (0, persistent_vars_1.deviceVar)('reloadPackagesOnPageRefresh', { defaultValue: true, });
-// export const packageLocalPathsResolved = persistentVar<{ [packageId: string]: string}>('packageLocalPathsResolved', { defaultValue: {}, scope: 'device' });

package/dist/data/packages.utils.d.ts

@@ -0,0 +1,3 @@
+import { IPackage } from "./packages";
+import { DataContext } from "../context/data-context";
+export declare function copyPackageToAnotherDataContext(packageId: string, fromDataContext: DataContext, toDataContext: DataContext): Promise<IPackage>;

package/dist/data/packages.utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyPackageToAnotherDataContext = copyPackageToAnotherDataContext;
+const packages_1 = require("./packages");
+const files_1 = require("./files");
+async function copyPackageToAnotherDataContext(packageId, fromDataContext, toDataContext) {
+    const fromPackages = (0, packages_1.Packages)(fromDataContext);
+    const toPackages = (0, packages_1.Packages)(toDataContext);
+    const pkg = await fromPackages.get(packageId);
+    if (!pkg) {
+        throw new Error(`Package ${packageId} not found in fromDataContext`);
+    }
+    const fromFiles = (0, files_1.Files)(fromDataContext);
+    const toFiles = (0, files_1.Files)(toDataContext);
+    const bundleFile = await fromFiles.get(pkg.packageBundleFileId);
+    if (bundleFile) {
+        await toFiles.saveFileRecord(bundleFile);
+    }
+    else {
+        throw new Error(`Package bundle file ${pkg.packageBundleFileId} not found in fromDataContext`);
+    }
+    if (pkg.routesBundleFileId) {
+        const routesBundleFile = await fromFiles.get(pkg.routesBundleFileId);
+        if (routesBundleFile) {
+            await toFiles.saveFileRecord(routesBundleFile);
+        }
+        else {
+            throw new Error(`Routes bundle file ${pkg.routesBundleFileId} not found in fromDataContext`);
+        }
+    }
+    if (pkg.uiBundleFileId) {
+        const uiBundleFile = await fromFiles.get(pkg.uiBundleFileId);
+        if (uiBundleFile) {
+            await toFiles.saveFileRecord(uiBundleFile);
+        }
+        else {
+            throw new Error(`UI bundle file ${pkg.uiBundleFileId} not found in fromDataContext`);
+        }
+    }
+    return toPackages.signAndSave(pkg);
+}

package/dist/keys.d.ts

@@ -26,7 +26,7 @@ export interface IDataBox {
     fromPublicKey: string;
 }
 export declare function newKeys(): IPublicPrivateKeys;
-export declare function loadKeys(secretKey: string): IPublicPrivateKeys;
+export declare function hydrateKeys(secretKey: string): IPublicPrivateKeys;
 export declare function signMessageWithSecretKey(msg: string, secretKey: string): string;
 export declare function openMessageWithPublicKey(msg: string, publicKey: string): string;
 export declare function signObjectWithSecretKey<T>(obj: T, secretKey: string): ISignedObject<T>;

package/dist/keys.js

@@ -9,7 +9,7 @@ exports.encodeBase64 = encodeBase64;
 exports.decodeBase64 = decodeBase64;
 exports.newToken = newToken;
 exports.newKeys = newKeys;
-exports.loadKeys = loadKeys;
+exports.hydrateKeys = hydrateKeys;
 exports.signMessageWithSecretKey = signMessageWithSecretKey;
 exports.openMessageWithPublicKey = openMessageWithPublicKey;
 exports.signObjectWithSecretKey = signObjectWithSecretKey;
@@ -80,7 +80,7 @@ function newKeys() {
         publicBoxKey: encodeBase64(boxKeyPair.publicKey),
     };
 }
-function loadKeys(secretKey) {
+function hydrateKeys(secretKey) {
     let _secretKey = decodeBase64(secretKey);
     const boxKeyPair = nacl.box.keyPair.fromSecretKey(_secretKey.slice(0, 32));
     return {

package/dist/keys.test.js

@@ -97,7 +97,7 @@ describe('keys', () => {
     describe('loading keys', () => {
         it('should allow loading keys from a secret key', () => {
             const keys = (0, keys_1.newKeys)();
-            const loadedKeys = (0, keys_1.loadKeys)(keys.secretKey);
+            const loadedKeys = (0, keys_1.hydrateKeys)(keys.secretKey);
             expect(loadedKeys.secretKey).toEqual(keys.secretKey);
             expect(loadedKeys.publicKey).toEqual(keys.publicKey);
             expect(loadedKeys.publicBoxKey).toEqual(keys.publicBoxKey);

package/dist/package-loader/package-loader.d.ts

@@ -11,6 +11,6 @@ export declare class PackageLoader {
     }): Promise<void>;
     loadPackage(pkg: IPackage, opts?: {
         force?: boolean;
-    }): Promise<IPeersPackage | null>;
+    }): Promise<IPeersPackage | undefined>;
 }
 export declare function setDefaultRequire(require: (<T>(module: string) => T)): void;

package/dist/package-loader/package-loader.js

@@ -31,13 +31,13 @@ class PackageLoader {
             let bundleCode = '';
             if (pkg.packageBundleFileId) {
                 const filesTable = (0, files_1.Files)(this.dataContext);
-                const bundleBuffer = await filesTable.getFile(pkg.packageBundleFileId);
+                const bundleBuffer = await filesTable.getFileContents(pkg.packageBundleFileId);
                 if (bundleBuffer) {
                     bundleCode = Buffer.from(bundleBuffer).toString('utf8');
                 }
                 else {
                     console.warn(`Package bundle file not found for ${pkg.name} (fileId: ${pkg.packageBundleFileId})`);
-                    return null;
+                    return;
                 }
             }
             else {
@@ -87,11 +87,11 @@ class PackageLoader {
                 });
                 return packageInstance;
             }
-            return null;
+            return;
         }
         catch (err) {
             console.debug(`Could not load package bundle for ${pkg.name}`, err);
-            return null;
+            return;
         }
     }
 }

package/dist/rpc-types.d.ts

@@ -8,17 +8,14 @@ export declare const rpcServerCalls: {
     openLinkInBrowser: ((url: string) => Promise<void>);
     openPath: ((path: string) => Promise<void>);
     openPackage: ((path: string) => Promise<void>);
-    createLocalPackage: ((packageName: string, packageLocation: string) => Promise<string>);
-    addRemotePackage: ((remoteRepo: string) => Promise<string>);
-    linkRemoteRepo: ((packageId: string) => Promise<void>);
-    installOrUpdatePackage: ((packageId: string) => Promise<void>);
+    addOrUpdatePackage: ((input: string, options?: {
+        dataContextId?: string;
+        packageLocation?: string;
+        update?: boolean;
+        linkRemote?: boolean;
+    }) => Promise<string>);
     setUserIdAndSecretKey: ((userId: string, secretKey: string) => Promise<void>);
     getUserId: () => Promise<string | undefined>;
-    updateUserSettings: ((settings: {
-        id: string;
-        name: string;
-        value: any;
-    }) => Promise<void>);
     encryptData: ((value: string, groupId?: string) => Promise<string>);
     tableGet: (dataContextId: string, tableName: string, id: string, opts?: {
         useCache?: boolean;

package/dist/rpc-types.js

@@ -8,17 +8,15 @@ function rpcStub(rpcName) {
 }
 exports.rpcServerCalls = {
     ping: async (msg) => `pong: ${msg}`,
+    // TODO collapse these two down to just openPath
     openLinkInBrowser: rpcStub('openLinkInBrowser'),
     openPath: rpcStub('openPath'),
     openPackage: rpcStub('OpenPackage'),
-    createLocalPackage: rpcStub('createLocalPackage'),
-    addRemotePackage: rpcStub('addRemotePackage'),
-    linkRemoteRepo: rpcStub('linkRemoteRepo'),
-    installOrUpdatePackage: rpcStub('installOrUpdatePackage'),
+    addOrUpdatePackage: rpcStub('addOrUpdatePackage'),
     setUserIdAndSecretKey: rpcStub('setUserIdAndSecretKey'),
     getUserId: rpcStub('getUserId'),
-    updateUserSettings: rpcStub('updateUserSettings'),
     encryptData: rpcStub('encryptData'),
+    // TODO collapse these all down to just tableMethodCall
     tableGet: rpcStub('tableGet'),
     tableList: rpcStub('tableList'),
     tableCount: rpcStub('tableCount'),
@@ -32,6 +30,8 @@ exports.rpcServerCalls = {
     resetAllDeviceSyncInfo: rpcStub('resetAllDeviceSyncInfo'),
     importGroupShare: rpcStub('importGroupShare'),
     // TODO try to get rid of this and rely on the client-side table and server-side table individually emitting events
+    // TODO TODO before deleting this, check if we can stop client-side tables from emitting events and rely solely on server-side tables
+    //           propagating events with rpcClientCalls.emitEvent.  It's very likely we're currently seeing two events for every one write originating from the UI
     // emitEvent: _na as ((event: IEventData) => Promise<boolean>),
 };
 exports.rpcClientCalls = {

package/dist/system-ids.d.ts

@@ -4,3 +4,5 @@ export declare const defaultAssistantRunnerToolId = "000peers0tool00000runner1";
 export declare const defaultSendMessageToolId = "000peers0tool00000sendmsg";
 export declare const runWorkflowToolId = "000peers0tool0runworkflow";
 export declare const emitEventToolId = "000peers0tool000emitevent";
+export declare const peersCorePackageId = "00mh0wlipjixk2gqmurbwee0o";
+export declare const peersCorePackageRepoUrl = "https://github.com/peers-app/peers-core";

package/dist/system-ids.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.emitEventToolId = exports.runWorkflowToolId = exports.defaultSendMessageToolId = exports.defaultAssistantRunnerToolId = exports.defaultAssistantId = exports.peersRootUserId = void 0;
+exports.peersCorePackageRepoUrl = exports.peersCorePackageId = exports.emitEventToolId = exports.runWorkflowToolId = exports.defaultSendMessageToolId = exports.defaultAssistantRunnerToolId = exports.defaultAssistantId = exports.peersRootUserId = void 0;
 exports.peersRootUserId = '000peers0user000000000001';
 exports.defaultAssistantId = '000peers0bot00000000shell';
 // export const defaultAssistantId = '000peers0bot000000000bot1';
@@ -8,3 +8,5 @@ exports.defaultAssistantRunnerToolId = '000peers0tool00000runner1';
 exports.defaultSendMessageToolId = '000peers0tool00000sendmsg';
 exports.runWorkflowToolId = '000peers0tool0runworkflow';
 exports.emitEventToolId = '000peers0tool000emitevent';
+exports.peersCorePackageId = '00mh0wlipjixk2gqmurbwee0o';
+exports.peersCorePackageRepoUrl = 'https://github.com/peers-app/peers-core';

package/package.json

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