@peers-app/peers-sdk 0.1.4

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageLoader = void 0;
+exports.setDefaultRequire = setDefaultRequire;
+const tools_1 = require("../tools");
+const files_1 = require("../data/files");
+const packages_1 = require("../data/packages");
+const tools_2 = require("../data/tools");
+class PackageLoader {
+    dataContext;
+    packageInstances = {};
+    require = undefined;
+    constructor(dataContext) {
+        this.dataContext = dataContext;
+    }
+    async loadAllPackages(opts) {
+        const packages = await (0, packages_1.Packages)(this.dataContext).list();
+        await Promise.all(packages.map(pkg => {
+            if (pkg.disabled) {
+                return;
+            }
+            return this.loadPackage(pkg, opts);
+        }));
+    }
+    async loadPackage(pkg, opts) {
+        if (this.packageInstances[pkg.packageId] && !opts?.force) {
+            return this.packageInstances[pkg.packageId];
+        }
+        // console.debug(`Loading package bundle for ${pkg.name} (${pkg.packageId})`);
+        try {
+            let bundleCode = '';
+            if (pkg.packageBundleFileId) {
+                const filesTable = (0, files_1.Files)(this.dataContext);
+                const bundleBuffer = await filesTable.getFile(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;
+                }
+            }
+            else {
+                console.warn(`Package ${pkg.name} does not have a bundle file defined.`);
+            }
+            // Create a safe execution context
+            const moduleExports = {};
+            const module = { exports: moduleExports };
+            // Create a custom require function that provides necessary dependencies
+            const customRequire = (moduleId) => {
+                // const require = getRequire(this.require);  
+                const _require = this.require ?? defaultRequire ?? typeof require === 'function' ? require : undefined;
+                if (!_require) {
+                    throw new Error('You must set the `require` function in package loader before loading a package');
+                }
+                // console.debug(`Custom require for module: ${moduleId}`);
+                switch (moduleId) {
+                    case 'peers-sdk':
+                    case 'PeersSDK':
+                        // Import all peers-sdk exports
+                        // return _require('peers-sdk');
+                        return _require('../index');
+                    case 'zod':
+                        return _require('zod');
+                    default:
+                        // For other modules, use the standard require
+                        console.warn(`Package ${pkg.name} is requiring a module ${moduleId}, which is not provided by the package loader.`);
+                        return _require(moduleId);
+                }
+            };
+            // Evaluate the bundle using Function (safer than eval)
+            const bundleFunction = new Function('module', 'exports', 'require', bundleCode);
+            bundleFunction(module, moduleExports, customRequire);
+            // Extract the package instance from the bundle exports
+            const bundleExports = module.exports;
+            const packageInstance = bundleExports?.exports || bundleExports?.package || bundleExports?.default || bundleExports;
+            this.packageInstances[pkg.packageId] = packageInstance;
+            if (packageInstance && typeof packageInstance === 'object') {
+                // Register tools centrally using the tools-factory
+                packageInstance.toolInstances?.forEach((toolInstance) => {
+                    // Note that this isn't unregistering prior tools when force loading
+                    (0, tools_1.registerTool)(toolInstance);
+                    (0, tools_2.Tools)(this.dataContext).save(toolInstance.tool);
+                });
+                packageInstance.tableDefinitions?.forEach((tableDefinition) => {
+                    this.dataContext.tableContainer.registerTableDefinition(tableDefinition, { overwrite: true });
+                });
+                return packageInstance;
+            }
+            return null;
+        }
+        catch (err) {
+            console.debug(`Could not load package bundle for ${pkg.name}`, err);
+            return null;
+        }
+    }
+}
+exports.PackageLoader = PackageLoader;
+let defaultRequire = undefined;
+function setDefaultRequire(require) {
+    defaultRequire = require;
+}

package/dist/peers-ui/peers-ui.d.ts

@@ -0,0 +1,15 @@
+import type { IPeersUIRoute } from "./peers-ui.types";
+import type { ZodObject, ZodArray, ZodAny, ZodTypeAny } from "zod";
+export interface IPeersUI {
+    peersUIId: string;
+    propsSchema: ZodObject<any> | ZodArray<any> | ZodAny | ZodTypeAny;
+    content: any;
+}
+export declare const PeersUI: (props: {
+    peersUIId?: string;
+    uiEditMode?: IPeersUIRoute["uiEditMode"];
+    uiCategory?: IPeersUIRoute["uiCategory"];
+    uiSubcategory?: IPeersUIRoute["uiSubcategory"];
+    children?: React.ReactNode;
+    props?: Record<string, any>;
+}) => (React.ReactNode | undefined);

package/dist/peers-ui/peers-ui.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeersUI = void 0;
+const PeersUI = (props
+// @ts-ignore
+) => {
+    if (typeof window === 'undefined') {
+        throw new Error("PeersUI can only be used in the browser");
+    }
+    const _window = window;
+    let ui;
+    if (props.peersUIId) {
+        ui = _window.UILoader(props);
+    }
+    else {
+        ui = _window.UIRouter(props);
+    }
+    if (ui) {
+        return ui;
+    }
+    return props.children;
+};
+exports.PeersUI = PeersUI;

package/dist/peers-ui/peers-ui.types.d.ts

@@ -0,0 +1,35 @@
+import type { ZodObject, ZodAny, ZodArray, ZodTypeAny } from "zod";
+export type UICategory = 'field' | 'list' | 'details' | 'screen' | 'list-item' | 'other' | '*';
+export type UIEditMode = 'view' | 'edit' | 'create' | '*';
+export type UIContextPropsSchema = ZodObject<any> | ZodAny | ZodArray<any> | ZodTypeAny;
+export interface UIContext {
+    /** The current screen path */
+    path?: string;
+    /** If this is specified, this route will only be considered when the caller specifies this value */
+    uiEditMode?: UIEditMode;
+    /** If this is specified, this route will only be considered when the caller specifies this value */
+    uiCategory?: UICategory;
+    /** If this is specified, this route will only be considered when the caller specifies this value */
+    uiSubcategory?: string;
+    propsSchema?: UIContextPropsSchema;
+}
+export interface IPeersUIRoute extends UIContext {
+    /**
+     * required to identify which package ui bundle contains the component
+     */
+    packageId: string;
+    /**
+     * required to identify which react component to render
+     */
+    peersUIId: string;
+    /**
+     * This should return true to indicate that this route should be used for the given data
+     */
+    isMatch?: (props: Record<string, any>, context: {
+        path: string;
+    } & UIContext) => boolean;
+    /**
+     * higher take precedent
+     */
+    priority?: number;
+}

package/dist/peers-ui/peers-ui.types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+;

package/dist/rpc-types.d.ts

@@ -0,0 +1,45 @@
+import type { DataFilter, IDataQueryParams, ISaveOptions } from "./data/orm";
+export interface IEventData<T = any> {
+    name: string;
+    data: T;
+}
+export declare const rpcServerCalls: {
+    ping: (msg: string) => Promise<string>;
+    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>);
+    updateUserSettings: ((settings: {
+        id: string;
+        name: string;
+        value: any;
+    }) => Promise<void>);
+    setSecretKey: ((secretKey: string) => Promise<void>);
+    encryptData: ((value: string, groupId?: string) => Promise<string>);
+    tableGet: (dataContextId: string, tableName: string, id: string, opts?: {
+        useCache?: boolean;
+        cacheTtlMs?: number;
+    }) => Promise<any>;
+    tableList: ((dataContextId: string, tableName: string, filter?: DataFilter<any>, opts?: IDataQueryParams<any>) => Promise<any[]>);
+    tableCount: ((dataContextId: string, tableName: string, filter?: DataFilter<any>) => Promise<number>);
+    tableSave: ((dataContextId: string, tableName: string, record: any, opts?: ISaveOptions) => Promise<any>);
+    tableInsert: ((dataContextId: string, tableName: string, record: any) => Promise<any>);
+    tableUpdate: ((dataContextId: string, tableName: string, record: any) => Promise<any>);
+    tableDelete: ((dataContextId: string, tableName: string, recordOrId: any) => Promise<any>);
+    tableMethodCall: ((dataContextId: string, tableName: string, methodName: string, ...args: any[]) => Promise<any>);
+    getFileContents: ((fileId: string, encoding?: BufferEncoding) => Promise<string>);
+    resetAllDeviceSyncInfo: (() => Promise<void>);
+    importGroupShare: ((groupShareJson: string) => Promise<string>);
+};
+export declare const rpcClientCalls: {
+    ping: (msg: string) => Promise<string>;
+    emitEvent: ((event: IEventData) => Promise<boolean>);
+    setClientPath: ((url: string) => Promise<void>);
+    openThread: ((threadId: string) => Promise<void>);
+};
+export type RpcServerNames = keyof typeof rpcServerCalls;
+export type RpcClientNames = keyof typeof rpcClientCalls;
+export declare const isClient: boolean;

package/dist/rpc-types.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClient = exports.rpcClientCalls = exports.rpcServerCalls = void 0;
+function rpcStub(rpcName) {
+    return async () => {
+        console.warn(rpcName + ': rpc fn not set. This means that an RPC call is happening before the RPC function has been set. This is either a race condition or the RPC handler was never set.');
+    };
+}
+exports.rpcServerCalls = {
+    ping: async (msg) => `pong: ${msg}`,
+    openLinkInBrowser: rpcStub('openLinkInBrowser'),
+    openPath: rpcStub('openPath'),
+    openPackage: rpcStub('OpenPackage'),
+    createLocalPackage: rpcStub('createLocalPackage'),
+    addRemotePackage: rpcStub('addRemotePackage'),
+    linkRemoteRepo: rpcStub('linkRemoteRepo'),
+    installOrUpdatePackage: rpcStub('installOrUpdatePackage'),
+    updateUserSettings: rpcStub('updateUserSettings'),
+    setSecretKey: rpcStub('setSecretKey'),
+    encryptData: rpcStub('encryptData'),
+    tableGet: rpcStub('tableGet'),
+    tableList: rpcStub('tableList'),
+    tableCount: rpcStub('tableCount'),
+    tableSave: rpcStub('tableSave'),
+    tableInsert: rpcStub('tableInsert'),
+    tableUpdate: rpcStub('tableUpdate'),
+    tableDelete: rpcStub('tableDelete'),
+    tableMethodCall: rpcStub('tableMethodCall'),
+    // TODO lock this down so not all code can get any file contents
+    getFileContents: rpcStub('getFileContents'),
+    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
+    // emitEvent: _na as ((event: IEventData) => Promise<boolean>),
+};
+exports.rpcClientCalls = {
+    ping: async (msg) => `pong: ${msg}`,
+    emitEvent: rpcStub('emitEvent'),
+    setClientPath: rpcStub('setClientPath'),
+    openThread: rpcStub('openThread'),
+};
+exports.isClient = typeof window !== 'undefined';
+if (exports.isClient) {
+    // @ts-ignore
+    const _window = window;
+    _window['rpc'] = exports.rpcServerCalls;
+}

package/dist/serial-json.d.ts

@@ -0,0 +1,5 @@
+export declare function isObject(x: any): x is Record<string, any>;
+export declare function toJSON(obj: any): any;
+export declare function fromJSON(obj: any, externalReferences?: any): any;
+export declare function toJSONString(obj: any): string;
+export declare function fromJSONString(str: string): any;

package/dist/serial-json.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = isObject;
+exports.toJSON = toJSON;
+exports.fromJSON = fromJSON;
+exports.toJSONString = toJSONString;
+exports.fromJSONString = fromJSONString;
+const _ = require("lodash");
+function isObject(x) {
+    return _.isObject(x) && !_.isArray(x) && !_.isDate(x) && x !== null;
+}
+function toJSON(obj) {
+    if (!_.isObject(obj)) {
+        return obj;
+    }
+    //console.log('toJSON');
+    const knownObjs = [];
+    const objRefs = [];
+    const newObjs = [];
+    let refCount = 0;
+    function recurse(obj) {
+        // stringify values
+        if (Number.isNaN(obj))
+            return "__NAN";
+        if (obj === undefined)
+            return "__UNDEFINED";
+        if (obj === Infinity)
+            return "__INFINITY";
+        if (obj instanceof RegExp)
+            return ("__REGEXP " + obj.toString());
+        //   if(isDate(obj))
+        //       return "__DATE " + obj.toISOString();
+        if (_.isDate(obj)) {
+            return "__DATE " + obj.toISOString();
+        }
+        if (_.isFunction(obj))
+            return '__FUNCTION ' + obj.toString();
+        if (_.isElement(obj)) {
+            return "__HTML " + obj.outerHTML;
+        }
+        if (typeof window !== 'undefined' && window && obj === window) {
+            return "__WINDOW";
+        }
+        if (_.isError(obj)) {
+            return "__ERROR " + obj.stack;
+        }
+        if (Buffer.isBuffer(obj)) {
+            // Convert Buffer to base64 string for JSON serialization (backward compatibility)
+            return "__BUFFER " + obj.toString('base64');
+        }
+        if (obj instanceof Uint8Array) {
+            // Convert Uint8Array to base64 string for JSON serialization
+            return "__UINT8ARRAY " + Buffer.from(obj).toString('base64');
+        }
+        // non-objects can just be returned at this point
+        if (!(isObject(obj) || _.isArray(obj))) {
+            return obj;
+        }
+        // if we've found a duplicate reference, deal with it
+        var iObj = knownObjs.indexOf(obj);
+        if (iObj >= 0) {
+            var ref = objRefs[iObj];
+            var nObj = newObjs[iObj];
+            if (_.isArray(nObj) && (!_.isString(nObj[0]) || !nObj[0].match(/^__this_ref:/)))
+                nObj.unshift("__this_ref:" + ref);
+            else if (isObject(nObj) && !nObj.__this_ref)
+                nObj.__this_ref = ref;
+            return ref;
+        }
+        // capture references in case we need them later
+        refCount++;
+        var newRef = "__duplicate_ref_" + (_.isArray(obj) ? "ary_" : "obj_") + refCount;
+        var nObj = _.isArray(obj) ? [] : {};
+        knownObjs.push(obj);
+        objRefs.push(newRef);
+        newObjs.push(nObj);
+        // recurse on properties
+        if (_.isArray(obj))
+            for (var i = 0; i < obj.length; i++)
+                nObj.push(recurse(obj[i])); // use push so offset from reference capture doesn't mess things up
+        else
+            for (var key in obj) {
+                if (!(obj && obj.hasOwnProperty && obj.hasOwnProperty(key)))
+                    continue;
+                var value = recurse(obj[key]);
+                if (key[0] == '$') // escape leading dollar signs
+                    key = '__DOLLAR_' + key.substring(1);
+                nObj[key] = value;
+            }
+        return nObj;
+    }
+    obj = recurse(obj);
+    return obj;
+}
+function fromJSON(obj, externalReferences) {
+    var dup_refs = {};
+    function recurse(obj) {
+        if (_.isString(obj)) {
+            // restore values
+            if (obj === "__UNDEFINED")
+                return undefined;
+            if (obj === "__NAN")
+                return NaN;
+            if (obj === "__INFINITY")
+                return Infinity;
+            if (obj.match(/^__REGEXP /)) {
+                var m = obj.split("__REGEXP ")[1].match(/\/(.*)\/(.*)?/);
+                return new RegExp(m[1], m[2] || "");
+            }
+            if (obj.startsWith("__DATE ")) {
+                return new Date(obj.substring(7));
+            }
+            // // assuming strings like this should be dates
+            // if (obj.match(/^\d{4}-\d{2}-\d{2}T\d{2}\:\d{2}\:\d{2}\.\d{3}Z$/)) {
+            //   return new Date(obj)
+            // }
+            // if (obj.match(/^__FUNCTION /)) {
+            //   return js(obj.substring(11), externalReferences);
+            // }
+            if (obj.match(/^__HTML /)) {
+                //@ts-ignore 
+                if (typeof $ !== 'undefined')
+                    return $(obj.substring(7))[0];
+                else
+                    return obj;
+            }
+            if (obj.startsWith("__ERROR ")) {
+                let error = new Error();
+                error.stack = obj.substring(8);
+                return error;
+            }
+            if (obj === "__WINDOW") {
+                return window;
+            }
+            if (obj.startsWith("__UINT8ARRAY ")) {
+                // Convert base64 string back to Uint8Array
+                return new Uint8Array(Buffer.from(obj.substring(13), 'base64'));
+            }
+            if (obj.startsWith("__BUFFER ")) {
+                // Convert base64 string back to Buffer (backward compatibility)
+                return Buffer.from(obj.substring(9), 'base64');
+            }
+            // deal with duplicate refs
+            if (obj.match(/^__duplicate_ref_/)) {
+                if (!dup_refs[obj])
+                    dup_refs[obj] = obj.match(/_obj_/) ? {} : [];
+                return dup_refs[obj];
+            }
+        }
+        if (!(isObject(obj) || _.isArray(obj)))
+            return obj;
+        // deal with objects that have duplicate refs
+        var dup_ref = null;
+        obj = _.clone(obj); // don't mess up the original JSON object
+        if (_.isArray(obj) && _.isString(obj[0]) && obj[0].match(/^__this_ref:/))
+            dup_ref = obj.shift().split(':')[1];
+        else if (obj.__this_ref) {
+            dup_ref = obj.__this_ref;
+            delete obj.__this_ref;
+        }
+        var mObj = _.isArray(obj) ? [] : {};
+        if (dup_ref)
+            if (!dup_refs[dup_ref])
+                dup_refs[dup_ref] = mObj;
+            else
+                mObj = dup_refs[dup_ref];
+        // restore keys and recurse on objects
+        for (var key in obj) {
+            if (!obj.hasOwnProperty(key))
+                continue;
+            var value = recurse(obj[key]);
+            if (key.match(/^__DOLLAR_/))
+                key = '$' + key.substring(9);
+            mObj[key] = value;
+        }
+        return mObj;
+    }
+    obj = recurse(obj);
+    return obj;
+}
+function toJSONString(obj) {
+    return JSON.stringify(toJSON(obj));
+}
+function fromJSONString(str) {
+    return fromJSON(JSON.parse(str));
+}

package/dist/serial-json.test.d.ts

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

package/dist/serial-json.test.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const serial_json_1 = require("./serial-json");
+describe('serial-json', () => {
+    describe('Uint8Array serialization', () => {
+        it('should serialize and deserialize Uint8Array correctly', () => {
+            const originalData = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]); // "Hello World"
+            const testObj = {
+                data: originalData,
+                name: 'test',
+                number: 42
+            };
+            // Test toJSON/fromJSON
+            const serialized = (0, serial_json_1.toJSON)(testObj);
+            expect(serialized.data).toMatch(/^__UINT8ARRAY /);
+            const deserialized = (0, serial_json_1.fromJSON)(serialized);
+            expect(deserialized.data).toBeInstanceOf(Uint8Array);
+            expect(deserialized.data).toEqual(originalData);
+            expect(deserialized.name).toBe('test');
+            expect(deserialized.number).toBe(42);
+        });
+        it('should serialize and deserialize nested Uint8Array correctly', () => {
+            const data1 = new Uint8Array([1, 2, 3]);
+            const data2 = new Uint8Array([4, 5, 6]);
+            const testObj = {
+                chunks: [data1, data2],
+                metadata: {
+                    firstChunk: data1,
+                    totalSize: 6
+                }
+            };
+            const serialized = (0, serial_json_1.toJSON)(testObj);
+            const deserialized = (0, serial_json_1.fromJSON)(serialized);
+            expect(deserialized.chunks).toHaveLength(2);
+            expect(deserialized.chunks[0]).toBeInstanceOf(Uint8Array);
+            expect(deserialized.chunks[1]).toBeInstanceOf(Uint8Array);
+            expect(deserialized.chunks[0]).toEqual(data1);
+            expect(deserialized.chunks[1]).toEqual(data2);
+            expect(deserialized.metadata.firstChunk).toBeInstanceOf(Uint8Array);
+            expect(deserialized.metadata.firstChunk).toEqual(data1);
+            expect(deserialized.metadata.totalSize).toBe(6);
+        });
+        it('should work with JSON string serialization', () => {
+            const originalData = new Uint8Array([255, 0, 128, 64]);
+            const testObj = { binaryData: originalData };
+            const jsonString = (0, serial_json_1.toJSONString)(testObj);
+            expect(typeof jsonString).toBe('string');
+            expect(jsonString).toContain('__UINT8ARRAY');
+            const deserialized = (0, serial_json_1.fromJSONString)(jsonString);
+            expect(deserialized.binaryData).toBeInstanceOf(Uint8Array);
+            expect(deserialized.binaryData).toEqual(originalData);
+        });
+    });
+    describe('Buffer backward compatibility', () => {
+        it('should serialize and deserialize Buffer correctly', () => {
+            const originalBuffer = Buffer.from('Hello Buffer');
+            const testObj = { bufferData: originalBuffer };
+            const serialized = (0, serial_json_1.toJSON)(testObj);
+            expect(serialized.bufferData).toMatch(/^__BUFFER /);
+            const deserialized = (0, serial_json_1.fromJSON)(serialized);
+            expect(Buffer.isBuffer(deserialized.bufferData)).toBe(true);
+            expect(deserialized.bufferData).toEqual(originalBuffer);
+        });
+    });
+    describe('existing functionality', () => {
+        it('should still handle other special types', () => {
+            const testObj = {
+                date: new Date('2023-01-01T00:00:00.000Z'),
+                regex: /test/gi,
+                error: new Error('test error'),
+                nan: NaN,
+                infinity: Infinity,
+                undef: undefined
+            };
+            const deserialized = (0, serial_json_1.fromJSON)((0, serial_json_1.toJSON)(testObj));
+            expect(deserialized.date).toBeInstanceOf(Date);
+            expect(deserialized.date.toISOString()).toBe('2023-01-01T00:00:00.000Z');
+            expect(deserialized.regex).toBeInstanceOf(RegExp);
+            expect(deserialized.regex.toString()).toBe('/test/gi');
+            expect(deserialized.error).toBeInstanceOf(Error);
+            expect(Number.isNaN(deserialized.nan)).toBe(true);
+            expect(deserialized.infinity).toBe(Infinity);
+            expect(deserialized.undef).toBeUndefined();
+        });
+    });
+});

package/dist/system-ids.d.ts

@@ -0,0 +1,6 @@
+export declare const peersRootUserId = "000peers0user000000000001";
+export declare const defaultAssistantId = "000peers0bot00000000shell";
+export declare const defaultAssistantRunnerToolId = "000peers0tool00000runner1";
+export declare const defaultSendMessageToolId = "000peers0tool00000sendmsg";
+export declare const runWorkflowToolId = "000peers0tool0runworkflow";
+export declare const emitEventToolId = "000peers0tool000emitevent";

package/dist/system-ids.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitEventToolId = exports.runWorkflowToolId = exports.defaultSendMessageToolId = exports.defaultAssistantRunnerToolId = exports.defaultAssistantId = exports.peersRootUserId = void 0;
+exports.peersRootUserId = '000peers0user000000000001';
+exports.defaultAssistantId = '000peers0bot00000000shell';
+// export const defaultAssistantId = '000peers0bot000000000bot1';
+exports.defaultAssistantRunnerToolId = '000peers0tool00000runner1';
+exports.defaultSendMessageToolId = '000peers0tool00000sendmsg';
+exports.runWorkflowToolId = '000peers0tool0runworkflow';
+exports.emitEventToolId = '000peers0tool000emitevent';

package/dist/tools/index.d.ts

@@ -0,0 +1 @@
+export * from './tools-factory';

package/dist/tools/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tools-factory"), exports);

package/dist/tools/tools-factory.d.ts

@@ -0,0 +1,5 @@
+import { IToolInstance } from "../data";
+export declare function registerTool(toolInstance: IToolInstance): void;
+export declare function getRegisteredTool(toolId: string): IToolInstance | undefined;
+export declare function getAllRegisteredTools(): IToolInstance[];
+export declare function clearRegisteredTools(): void;

package/dist/tools/tools-factory.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTool = registerTool;
+exports.getRegisteredTool = getRegisteredTool;
+exports.getAllRegisteredTools = getAllRegisteredTools;
+exports.clearRegisteredTools = clearRegisteredTools;
+const keys_1 = require("../keys");
+const registeredToolInstances = {};
+function registerTool(toolInstance) {
+    const toolId = toolInstance.tool.toolId;
+    if (registeredToolInstances[toolId]) {
+        const s1 = (0, keys_1.stableStringify)(registeredToolInstances[toolId].tool);
+        const s2 = (0, keys_1.stableStringify)(toolInstance.tool);
+        if (s1 !== s2) {
+            console.warn(`Attempt to register new tool with existing toolId ${toolId}, it will be ignored`, {
+                registered: registeredToolInstances[toolId].tool,
+                incoming: toolInstance.tool
+            });
+        }
+        return;
+    }
+    registeredToolInstances[toolId] = toolInstance;
+}
+function getRegisteredTool(toolId) {
+    return registeredToolInstances[toolId];
+}
+function getAllRegisteredTools() {
+    return Object.values(registeredToolInstances);
+}
+function clearRegisteredTools() {
+    Object.keys(registeredToolInstances).forEach(key => {
+        delete registeredToolInstances[key];
+    });
+}

package/dist/types/app-nav.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export declare const appNavSchema: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodOptional<z.ZodString>;
+    iconClassName: z.ZodString;
+    navigationPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    iconClassName: string;
+    navigationPath: string;
+    displayName?: string | undefined;
+}, {
+    name: string;
+    iconClassName: string;
+    navigationPath: string;
+    displayName?: string | undefined;
+}>;
+export type IAppNav = z.infer<typeof appNavSchema>;