@peers-app/peers-sdk 0.7.3 → 0.7.5

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

@@ -55,7 +55,7 @@ function getTableContainer(dataContext) {
 }
 function setDefaultClientUserContext(userId) {
     const clientProxyDataSourceFactory = (metaData, schema, groupId) => {
-        return new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema, groupId ?? '');
+        return new client_proxy_data_source_1.ClientProxyDataSource(metaData, schema, groupId || userId);
     };
     const userContext = new user_context_1.UserContext(userId, clientProxyDataSourceFactory);
     (async () => {
@@ -88,6 +88,12 @@ if (!rpc_types_1.isClient) {
     }
     // TODO: add check that client has permission to make this call
     rpc_types_1.rpcServerCalls.tableMethodCall = async (dataContextId, tableName, methodName, ...args) => {
+        if (!tableName) {
+            throw new Error('tableName is required for tableMethodCall');
+        }
+        if (!dataContextId) {
+            console.warn('dataContextId not provided to tableMethodCall - defaulting to user context.  This is discouraged. If userDataContext was intended then pass it in explicitly.');
+        }
         const table = await getTable(dataContextId, tableName);
         const method = table[methodName];
         if (typeof method !== 'function') {

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

@@ -8,7 +8,6 @@ export declare class UserContext {
     readonly dataSourceFactory: DataSourceFactory;
     readonly deviceId: Observable<string>;
     readonly currentlyActiveGroupId: Observable<string | undefined>;
-    readonly packagesRootDir: Observable<string>;
     readonly reloadPackagesOnPageRefresh: Observable<boolean>;
     readonly groupIds: Observable<string[]>;
     readonly userDataContext: DataContext;
@@ -40,7 +39,7 @@ export declare class UserContext {
     syncUserAndGroupObjects(userId: string, keys: IPublicPrivateKeys, me?: IUser): Promise<void>;
     subscribeToDataChangedAcrossAllGroups<T extends {
         [key: string]: any;
-    }>(table: Table<T>, handler: (evt: ICrossGroupSubscriptionHandlerArgs<T>) => any): import("../events").ISubscriptionResult;
+    }>(table: string | Table<T>, handler: (evt: ICrossGroupSubscriptionHandlerArgs<T>) => any): import("../events").ISubscriptionResult;
 }
 export interface ICrossGroupSubscriptionHandlerArgs<T> {
     name: string;

package/dist/context/user-context.js

@@ -13,7 +13,6 @@ class UserContext {
     dataSourceFactory;
     deviceId = (0, observable_1.observable)('');
     currentlyActiveGroupId = (0, observable_1.observable)();
-    packagesRootDir = (0, observable_1.observable)('');
     reloadPackagesOnPageRefresh = (0, observable_1.observable)(false);
     groupIds = (0, observable_1.observable)([]);
     userDataContext;
@@ -29,7 +28,12 @@ class UserContext {
         this.loadingPromise = this.init();
     }
     async init() {
-        await this.loadUserContextObservablesFromDB();
+        if (typeof process !== 'undefined' && process.env.NODE_ENV === 'test') {
+            console.log(`not setting up user-context pvars during tests because they will interfere with other UserContext instances`);
+        }
+        else {
+            await this.loadUserContextObservablesFromDB();
+        }
         await this.loadGroupContexts();
         await this.loadAllPackages();
         return this;
@@ -106,8 +110,9 @@ class UserContext {
      * for the user context to be fully loaded before proceeding with standard data access
      */
     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'] } });
+        // const persistentVars: PersistentVarsTable = await this.userDataContext.tableContainer.getTableByName(persistentVarsMetaData.name) as PersistentVarsTable;
+        const persistentVars = (0, data_1.PersistentVars)(this.userDataContext);
+        const vars = await persistentVars.list({ name: { $in: ['thisDeviceId', 'currentlyActiveGroupId', 'reloadPackagesOnPageRefresh'] } });
         const varDbValues = vars.reduce((acc, curr) => {
             acc[curr.name] = curr.value?.value;
             return acc;
@@ -119,15 +124,11 @@ class UserContext {
         const currentlyActiveGroupIdPVar = (0, data_1.deviceVar)('currentlyActiveGroupId', { dbValue: varDbValues['currentlyActiveGroupId'], defaultValue: '', userContext: this });
         this.currentlyActiveGroupId(currentlyActiveGroupIdPVar());
         (0, observable_1.linkObservables)(currentlyActiveGroupIdPVar, this.currentlyActiveGroupId);
-        const packagesRootDirPVar = (0, data_1.deviceVar)('packagesRootDir', { defaultValue: '~/peers-packages', dbValue: varDbValues['packagesRootDir'], userContext: this });
-        this.packagesRootDir(packagesRootDirPVar());
-        (0, observable_1.linkObservables)(packagesRootDirPVar, this.packagesRootDir);
         const reloadPackagesOnPageRefreshPVar = (0, data_1.deviceVar)('reloadPackagesOnPageRefresh', { defaultValue: false, dbValue: varDbValues['reloadPackagesOnPageRefresh'], userContext: this });
         this.reloadPackagesOnPageRefresh(reloadPackagesOnPageRefreshPVar());
         (0, observable_1.linkObservables)(reloadPackagesOnPageRefreshPVar, this.reloadPackagesOnPageRefresh);
         await Promise.all([
             deviceIdPVar.loadingPromise,
-            packagesRootDirPVar.loadingPromise,
             reloadPackagesOnPageRefreshPVar.loadingPromise,
         ]);
     }
@@ -185,7 +186,8 @@ class UserContext {
         }
     }
     subscribeToDataChangedAcrossAllGroups(table, handler) {
-        const tableEventPrefix = `${table.tableName}_DataChanged_`;
+        const tableName = typeof table === 'string' ? table : table.tableName;
+        const tableEventPrefix = `${tableName}_DataChanged_`;
         const subscription = (0, events_1.subscribe)(evt => evt.name.startsWith(tableEventPrefix), async (evt) => {
             const dataContextId = evt.name.endsWith('_') ? this.userId : evt.name.split('_').pop();
             const dataContext = this.getDataContext(dataContextId);

package/dist/data/data-locks.test.js

@@ -90,6 +90,9 @@ class MockPeerDevice {
             timestampLastApplied: Date.now()
         }));
     }
+    sendDeviceMessage(message) {
+        throw new Error('Method not implemented.');
+    }
 }
 describe('data-locks.ts', () => {
     const fiveMinutesMs = 5 * 60 * 1000;

package/dist/data/orm/decorators.js

@@ -11,9 +11,10 @@ function ProxyClientTableMethodCalls() {
     return function (target, context) {
         if (context.kind === 'method' && rpc_types_1.isClient) {
             const methodName = context.name;
-            return function (table, ...args) {
-                const dataContextId = table.groupId || '';
-                return rpc_types_1.rpcServerCalls.tableMethodCall(dataContextId, table.tableName, methodName, ...args);
+            // WARNING: Using typescript's magical `this` param
+            return function (...args) {
+                const dataContextId = this.dataSource.dataContextId || this.groupId || '';
+                return rpc_types_1.rpcServerCalls.tableMethodCall(dataContextId, this.tableName, methodName, ...args);
             };
         }
         return target;

package/dist/data/persistent-vars.js

@@ -136,145 +136,150 @@ function persistentVarFactory(name, opts) {
     let isSecret = opts.isSecret;
     let rec = undefined;
     persistentVar.loadingPromise = new Promise(async (resolve) => {
-        const userContext = opts?.userContext || await (0, user_context_singleton_1.getUserContext)();
-        function getDataContext() {
-            if (opts?.dataContext) {
-                return opts.dataContext;
-            }
-            if (scope === 'group') {
-                return userContext.defaultDataContext();
-            }
-            else {
-                return userContext.userDataContext;
-            }
-        }
-        function getVarNameInDb() {
-            if (scope === 'groupDevice' || scope === 'groupUser') {
-                const dc = opts?.dataContext || userContext.defaultDataContext();
-                // if it's a group var saved in the user's personal db, it's postfixed with the dataContextId to make it unique
-                return name + `_` + dc.dataContextId;
-            }
-            return name;
-        }
-        async function loadRecFromDb() {
-            const dc = getDataContext();
-            const table = PersistentVars(dc);
-            const name = getVarNameInDb();
-            let dbRec = await table.findOne({ 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`);
-                    await table.delete(dbRec);
-                    dbRec = undefined;
+        try {
+            const userContext = opts?.userContext || await (0, user_context_singleton_1.getUserContext)();
+            function getDataContext() {
+                if (opts?.dataContext) {
+                    return opts.dataContext;
+                }
+                if (scope === 'group') {
+                    return userContext.defaultDataContext();
+                }
+                else {
+                    return userContext.userDataContext;
                 }
             }
-            if (!dbRec) {
-                dbRec = {
-                    persistentVarId: '',
-                    name,
-                    scope,
-                    isSecret,
-                    value: { value: defaultValue },
-                };
-            }
-            // if the db says it's secret but the caller didn't specify, assume it's secret
-            if (dbRec.isSecret !== undefined && opts.isSecret === undefined) {
-                isSecret = dbRec.isSecret;
-            }
-            return dbRec;
-        }
-        async function reactToValueChanged(value) {
-            if (name === 'colorModePreference')
-                console.log(`colorModePreferences pvar value set: ${value}`);
-            if (!rec?.persistentVarId && value === defaultValue) {
-                return;
-            }
-            if (!rec?.persistentVarId) {
-                rec = await loadRecFromDb();
-            }
-            const oldValue = rec.value.value;
-            if ((0, lodash_1.isEqual)(value, oldValue)) {
-                return;
+            function getVarNameInDb() {
+                if (scope === 'groupDevice' || scope === 'groupUser') {
+                    const dc = opts?.dataContext || userContext.defaultDataContext();
+                    // if it's a group var saved in the user's personal db, it's postfixed with the dataContextId to make it unique
+                    return name + `_` + dc.dataContextId;
+                }
+                return name;
             }
-            rec.value.value = value;
-            const dc = getDataContext();
-            const table = PersistentVars(dc);
-            // delete if value equals default value
-            if ((0, lodash_1.isEqual)(rec.value.value, defaultValue)) {
-                if (rec.persistentVarId) {
-                    if (name === 'colorModePreference') {
-                        console.log(`deleted persistent var ${name} from db:`, rec.value.value);
+            async function loadRecFromDb() {
+                const dc = getDataContext();
+                const table = PersistentVars(dc);
+                const name = getVarNameInDb();
+                let dbRec = await table.findOne({ 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`);
+                        await table.delete(dbRec);
+                        dbRec = undefined;
                     }
-                    await table.delete(rec);
                 }
-                rec = undefined;
+                if (!dbRec) {
+                    dbRec = {
+                        persistentVarId: '',
+                        name,
+                        scope,
+                        isSecret,
+                        value: { value: defaultValue },
+                    };
+                }
+                // if the db says it's secret but the caller didn't specify, assume it's secret
+                if (dbRec.isSecret !== undefined && opts.isSecret === undefined) {
+                    isSecret = dbRec.isSecret;
+                }
+                return dbRec;
             }
-            else {
-                try {
-                    await table.save(rec);
-                    if (name === 'colorModePreference') {
-                        console.log(`Saved var ${name} to db:`, rec.value.value);
+            async function reactToValueChanged(value) {
+                if (name === 'colorModePreference')
+                    console.log(`colorModePreferences pvar value set: ${value}`);
+                if (!rec?.persistentVarId && value === defaultValue) {
+                    return;
+                }
+                if (!rec?.persistentVarId) {
+                    rec = await loadRecFromDb();
+                }
+                const oldValue = rec.value.value;
+                if ((0, lodash_1.isEqual)(value, oldValue)) {
+                    return;
+                }
+                rec.value.value = value;
+                const dc = getDataContext();
+                const table = PersistentVars(dc);
+                // delete if value equals default value
+                if ((0, lodash_1.isEqual)(rec.value.value, defaultValue)) {
+                    if (rec.persistentVarId) {
+                        if (name === 'colorModePreference') {
+                            console.log(`deleted persistent var ${name} from db:`, rec.value.value);
+                        }
+                        await table.delete(rec);
                     }
+                    rec = undefined;
                 }
-                catch (err) {
-                    const errMsg = err?.message || String(err) || '';
-                    if (errMsg.includes('UNIQUE constraint failed')) {
-                        console.warn(`Detected UNIQUE constraint failed error when saving persistent var, reloading and retrying: ${name}`);
-                        rec = await loadRecFromDb();
-                        persistentVar(rec.value.value);
+                else {
+                    try {
+                        await table.save(rec);
+                        if (name === 'colorModePreference') {
+                            console.log(`Saved var ${name} to db:`, rec.value.value);
+                        }
                     }
-                    else {
-                        console.error('Error saving persistent var', { name, value, rec, err });
-                        throw err;
+                    catch (err) {
+                        const errMsg = err?.message || String(err) || '';
+                        if (errMsg.includes('UNIQUE constraint failed')) {
+                            console.warn(`Detected UNIQUE constraint failed error when saving persistent var, reloading and retrying: ${name}`);
+                            rec = await loadRecFromDb();
+                            persistentVar(rec.value.value);
+                        }
+                        else {
+                            console.error('Error saving persistent var', { name, value, rec, err });
+                            throw err;
+                        }
                     }
                 }
             }
-        }
-        // subscribe to db changes
-        userContext.subscribeToDataChangedAcrossAllGroups(PersistentVars(), async (evt) => {
-            const dbRec = evt.data.dataObject;
-            const dbName = getVarNameInDb();
-            if (!rec?.persistentVarId && dbRec.name === dbName) {
-                rec = dbRec;
-            }
-            if (dbRec.persistentVarId === rec?.persistentVarId) {
-                if (evt.data.op === 'delete') {
-                    rec = undefined;
-                    if (defaultValue !== undefined) {
-                        persistentVar(defaultValue);
-                    }
-                }
-                else {
+            // subscribe to db changes
+            userContext.subscribeToDataChangedAcrossAllGroups(exports.persistentVarsMetaData.name, async (evt) => {
+                const dbRec = evt.data.dataObject;
+                const dbName = getVarNameInDb();
+                if (!rec?.persistentVarId && dbRec.name === dbName) {
                     rec = dbRec;
-                    if (!(0, lodash_1.isEqual)(persistentVar(), rec.value.value)) {
-                        persistentVar(rec.value.value);
+                }
+                if (dbRec.persistentVarId === rec?.persistentVarId) {
+                    if (evt.data.op === 'delete') {
+                        rec = undefined;
+                        if (defaultValue !== undefined) {
+                            persistentVar(defaultValue);
+                        }
+                    }
+                    else {
+                        rec = dbRec;
+                        if (!(0, lodash_1.isEqual)(persistentVar(), rec.value.value)) {
+                            persistentVar(rec.value.value);
+                        }
                     }
                 }
+            });
+            // update group-dependent variables if group context changes and it hasn't been pinned to a specific data context
+            const groupDependentScopes = ['group', 'groupDevice', 'groupUser'];
+            if (!opts?.dataContext && groupDependentScopes.includes(scope)) {
+                userContext.defaultDataContext.subscribe(async () => {
+                    rec = await loadRecFromDb();
+                    persistentVar(rec.value.value);
+                });
             }
-        });
-        // update group-dependent variables if group context changes and it hasn't been pinned to a specific data context
-        const groupDependentScopes = ['group', 'groupDevice', 'groupUser'];
-        if (!opts?.dataContext && groupDependentScopes.includes(scope)) {
-            userContext.defaultDataContext.subscribe(async () => {
+            if (!setWithDbValue) {
                 rec = await loadRecFromDb();
-                persistentVar(rec.value.value);
-            });
-        }
-        if (!setWithDbValue) {
-            rec = await loadRecFromDb();
-            if (!(0, lodash_1.isEqual)(rec.value.value, persistentVar())) {
-                if (name === 'colorModePreference') {
-                    console.log(`Loaded persistent var ${name} from db:`, rec.value.value);
+                if (!(0, lodash_1.isEqual)(rec.value.value, persistentVar())) {
+                    if (name === 'colorModePreference') {
+                        console.log(`Loaded persistent var ${name} from db:`, rec.value.value);
+                    }
+                    persistentVar(rec.value.value);
                 }
-                persistentVar(rec.value.value);
             }
-        }
-        persistentVar.subscribe(newValue => {
-            persistentVar.loadingPromise = persistentVar.loadingPromise.then(async () => {
-                await reactToValueChanged(newValue);
-                return persistentVar;
+            persistentVar.subscribe(newValue => {
+                persistentVar.loadingPromise = persistentVar.loadingPromise.then(async () => {
+                    await reactToValueChanged(newValue);
+                    return persistentVar;
+                });
             });
-        });
+        }
+        catch (err) {
+            console.error(`an unexpected occurred while loading a persistent var: ${name}`, err);
+        }
         resolve(persistentVar);
     });
     return persistentVar;

package/dist/device/connection.js

@@ -201,7 +201,7 @@ class Connection {
         if (this.trustLevel < socket_type_1.TrustLevel.Unknown) {
             throw new Error('Untrusted connection');
         }
-        console.log(new Date().toISOString(), `Connection ${this.connectionId} verified on server side with trust level ${this.trustLevel}`);
+        console.log(`Connection ${this.connectionId} verified on server side with trust level ${this.trustLevel}`);
         this._verified = true;
         if (this.onHandshakeComplete) {
             setTimeout(() => {
@@ -239,7 +239,7 @@ class Connection {
             this.emit('reset');
             throw new Error('Untrusted connection');
         }
-        console.log(new Date().toISOString(), `Connection ${this.connectionId} (${remoteAddress}) verified on client side with trust level ${this.trustLevel}`);
+        console.log(`Connection ${this.connectionId} (${remoteAddress}) verified on client side with trust level ${this.trustLevel}`);
         return handshakeResponse;
     }
 }

package/dist/device/get-trust-level.js

@@ -64,7 +64,7 @@ function getTrustLevelFn(me, serverUrl) {
         //       console.error(new Date().toISOString(), 'Error getting trust level from server', serverUrl, err);
         //       return TrustLevel.Unknown;
         //     });
-        //     console.log(new Date().toISOString(), 'Remote trust level', { _remoteTrustLevel, serverUrl, remoteUrlBeingChecked: serverUrl });
+        //     console.log('Remote trust level', { _remoteTrustLevel, serverUrl, remoteUrlBeingChecked: serverUrl });
         //     if (_remoteTrustLevel < TrustLevel.Unknown) {
         //       console.error(new Date().toISOString(), 'Unverified user failed trust check', { user, remoteTrustLevel });
         //       device.trustLevel = _remoteTrustLevel;

package/dist/index.d.ts

@@ -31,3 +31,4 @@ export * from "./observable";
 export * from "./rpc-types";
 export * from "./serial-json";
 export * from "./utils";
+export * from "./logging";

package/dist/index.js

@@ -48,3 +48,4 @@ __exportStar(require("./observable"), exports);
 __exportStar(require("./rpc-types"), exports);
 __exportStar(require("./serial-json"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./logging"), exports);

package/dist/logging/console-logger.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Setup console proxy to capture all console output and write to ConsoleLogs table.
+ * Also subscribes to dataChanged events to output logs from other process instances.
+ * @param processName - The name of the process (e.g., 'main', 'renderer')
+ */
+export declare function setupConsoleProxy(processName: string): Promise<void>;
+/**
+ * Restore original console methods
+ */
+export declare function restoreConsole(): void;

package/dist/logging/console-logger.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupConsoleProxy = setupConsoleProxy;
+exports.restoreConsole = restoreConsole;
+const utils_1 = require("../utils");
+const console_logs_table_1 = require("./console-logs.table");
+// Store original console methods
+const originalConsole = {
+    debug: console.debug,
+    info: console.info,
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+};
+let isProxySetup = false;
+let currentProcessName = 'unknown';
+let currentProcessInstanceId = '';
+/**
+ * Setup console proxy to capture all console output and write to ConsoleLogs table.
+ * Also subscribes to dataChanged events to output logs from other process instances.
+ * @param processName - The name of the process (e.g., 'main', 'renderer')
+ */
+async function setupConsoleProxy(processName) {
+    if (isProxySetup) {
+        console.warn('Console proxy already setup, skipping...');
+        return;
+    }
+    isProxySetup = true;
+    currentProcessName = processName;
+    currentProcessInstanceId = (0, utils_1.newid)(); // Unique ID for this process instance
+    const levels = ['debug', 'info', 'log', 'warn', 'error'];
+    // Monkey-patch console methods to capture local logs
+    levels.forEach((level) => {
+        const original = originalConsole[level];
+        console[level] = function (...args) {
+            // Always call original console method first (preserve terminal output)
+            original.apply(console, args);
+            // Asynchronously write to database (don't block console output)
+            writeLogToDatabase(level, args).catch((err) => {
+                // Use original console to avoid infinite recursion
+                originalConsole.error('Failed to write log to database:', err);
+            });
+        };
+    });
+    // Subscribe to dataChanged events to output logs from OTHER process instances
+    try {
+        const consoleLogsTable = await (0, console_logs_table_1.ConsoleLogs)();
+        consoleLogsTable.dataChanged.subscribe((evt) => {
+            const log = evt.dataObject;
+            // Skip if this is our own log
+            if (log.processInstanceId === currentProcessInstanceId) {
+                return;
+            }
+            // Output log from another process with prefix
+            const colorCode = log.process === 'renderer' ? '\x1b[36m' : '\x1b[35m'; // cyan for renderer, magenta for main
+            const resetCode = '\x1b[0m';
+            const prefix = `${colorCode}[${log.process}]${resetCode}`;
+            const logLevel = log.level;
+            const logArgs = [prefix, log.message];
+            if (log.context) {
+                logArgs.push(log.context);
+            }
+            if (originalConsole[logLevel]) {
+                originalConsole[logLevel](...logArgs);
+            }
+            else {
+                originalConsole.log(...logArgs);
+            }
+            // Also output stack trace for errors
+            if (log.stackTrace) {
+                originalConsole.error(log.stackTrace);
+            }
+        });
+    }
+    catch (err) {
+        originalConsole.error('Failed to subscribe to console logs dataChanged:', err);
+    }
+    console.log(`Console proxy initialized for process: ${processName} (instance: ${currentProcessInstanceId})`);
+}
+/**
+ * Restore original console methods
+ */
+function restoreConsole() {
+    if (!isProxySetup) {
+        return;
+    }
+    console.debug = originalConsole.debug;
+    console.info = originalConsole.info;
+    console.log = originalConsole.log;
+    console.warn = originalConsole.warn;
+    console.error = originalConsole.error;
+    isProxySetup = false;
+    originalConsole.log('Console proxy removed, original console restored');
+}
+/**
+ * Write a log entry to the ConsoleLogs table
+ */
+async function writeLogToDatabase(level, args) {
+    try {
+        // Format message from arguments
+        const message = formatLogMessage(args);
+        // Extract context objects from arguments
+        const context = extractContext(args);
+        // Get stack trace for errors
+        const stackTrace = level === 'error' ? getStackTrace() : undefined;
+        // Extract source from stack trace
+        const source = extractSource(stackTrace);
+        const logRecord = {
+            logId: (0, utils_1.newid)(),
+            timestamp: (0, utils_1.getTimestamp)(),
+            level,
+            process: currentProcessName,
+            processInstanceId: currentProcessInstanceId,
+            source,
+            message,
+            context,
+            stackTrace,
+        };
+        const consoleLogsTable = await (0, console_logs_table_1.ConsoleLogs)();
+        await consoleLogsTable.insert(logRecord);
+    }
+    catch (err) {
+        // Silently fail if table not available (e.g., during initialization)
+        // Don't use console here to avoid infinite recursion
+    }
+}
+/**
+ * Format log arguments into a single message string
+ */
+function formatLogMessage(args) {
+    return args.map((arg) => {
+        if (typeof arg === 'string') {
+            return arg;
+        }
+        if (arg instanceof Error) {
+            return `${arg.name}: ${arg.message}`;
+        }
+        if (typeof arg === 'object') {
+            try {
+                return JSON.stringify(arg);
+            }
+            catch {
+                return String(arg);
+            }
+        }
+        return String(arg);
+    }).join(' ');
+}
+/**
+ * Extract structured context objects from log arguments
+ */
+function extractContext(args) {
+    const objects = args.filter((arg) => arg && typeof arg === 'object' && !(arg instanceof Error) && !(arg instanceof Date));
+    if (objects.length === 0) {
+        return undefined;
+    }
+    if (objects.length === 1) {
+        return objects[0];
+    }
+    // Merge multiple objects
+    return Object.assign({}, ...objects);
+}
+/**
+ * Get current stack trace
+ */
+function getStackTrace() {
+    try {
+        const stack = new Error().stack;
+        if (!stack)
+            return undefined;
+        // Remove first few lines (Error message and this function's frames)
+        const lines = stack.split('\n');
+        return lines.slice(4).join('\n');
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Extract source file/module from stack trace
+ */
+function extractSource(stackTrace) {
+    if (!stackTrace)
+        return undefined;
+    try {
+        const lines = stackTrace.split('\n');
+        if (lines.length === 0)
+            return undefined;
+        // Get first line of stack (caller's location)
+        const firstLine = lines[0];
+        // Extract file path from patterns like:
+        // "at function (file:///path/to/file.ts:123:45)"
+        // "at file:///path/to/file.ts:123:45"
+        const match = firstLine.match(/\((.*?):\d+:\d+\)|at (.*?):\d+:\d+/);
+        if (match) {
+            const path = match[1] || match[2];
+            // Extract just the filename
+            const filename = path.split('/').pop()?.split('?')[0];
+            return filename;
+        }
+    }
+    catch {
+        // Ignore parsing errors
+    }
+    return undefined;
+}

package/dist/logging/console-logs.table.d.ts

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { ITableMetaData } from "../data/orm/types";
+import { ITableDependencies, Table } from "../data/orm";
+export declare const consoleLogSchema: z.ZodObject<{
+    logId: z.ZodEffects<z.ZodString, string, string>;
+    timestamp: z.ZodDefault<z.ZodNumber>;
+    level: z.ZodEnum<["debug", "info", "log", "warn", "error"]>;
+    process: z.ZodString;
+    processInstanceId: z.ZodString;
+    source: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
+    stackTrace: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    timestamp: number;
+    logId: string;
+    level: "error" | "debug" | "info" | "log" | "warn";
+    process: string;
+    processInstanceId: string;
+    source?: string | undefined;
+    context?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
+    stackTrace?: string | undefined;
+}, {
+    message: string;
+    logId: string;
+    level: "error" | "debug" | "info" | "log" | "warn";
+    process: string;
+    processInstanceId: string;
+    source?: string | undefined;
+    timestamp?: number | undefined;
+    context?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
+    stackTrace?: string | undefined;
+}>;
+export type IConsoleLog = z.infer<typeof consoleLogSchema>;
+export declare class ConsoleLogsTable extends Table<IConsoleLog> {
+    readonly LOG_TTL: number;
+    readonly LOG_CLEANUP_INTERVAL: number;
+    constructor(metaData: ITableMetaData, deps: ITableDependencies);
+    private logCleanupInitialized;
+    initializeLogCleanup(): Promise<void>;
+    deleteOldLogs(cutoffTimestamp?: number): Promise<void>;
+}
+/**
+ * We always use the user's personal data context so all logs are written to the same place.  This requires
+ * that the table be accessed in an asynchronous way
+ */
+export declare function ConsoleLogs(): Promise<ConsoleLogsTable>;

package/dist/logging/console-logs.table.js

@@ -0,0 +1,140 @@
+"use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLogsTable = exports.consoleLogSchema = void 0;
+exports.ConsoleLogs = ConsoleLogs;
+const zod_1 = require("zod");
+const zod_types_1 = require("../types/zod-types");
+const types_1 = require("../data/orm/types");
+const user_context_singleton_1 = require("../context/user-context-singleton");
+const table_definitions_system_1 = require("../data/orm/table-definitions.system");
+const utils_1 = require("../utils");
+const orm_1 = require("../data/orm");
+exports.consoleLogSchema = zod_1.z.object({
+    logId: zod_types_1.zodPeerId,
+    timestamp: zod_1.z.number().default(() => (0, utils_1.getTimestamp)()).describe('The timestamp the log was created created'),
+    level: zod_1.z.enum(['debug', 'info', 'log', 'warn', 'error']).describe('The log level'),
+    process: zod_1.z.string().describe('The process that generated the log (e.g., main, renderer, worker)'),
+    processInstanceId: zod_1.z.string().describe('Unique ID for this process instance to filter own logs'),
+    source: zod_1.z.string().optional().describe('The source file or module that generated the log'),
+    message: zod_1.z.string().describe('The log message'),
+    context: zod_types_1.zodAnyObject.optional().describe('Additional structured context data'),
+    stackTrace: zod_1.z.string().optional().describe('Stack trace for errors'),
+});
+const metaData = {
+    name: 'ConsoleLogs',
+    description: 'System-wide console log entries with cross-process visibility.',
+    primaryKeyName: 'logId',
+    fields: (0, types_1.schemaToFields)(exports.consoleLogSchema),
+    localOnly: true, // Don't sync logs between devices
+    indexes: [
+        { fields: ['timestamp'] },
+        { fields: ['level'] },
+        { fields: ['process'] },
+        { fields: ['processInstanceId'] },
+    ],
+};
+let ConsoleLogsTable = (() => {
+    let _classSuper = orm_1.Table;
+    let _instanceExtraInitializers = [];
+    let _initializeLogCleanup_decorators;
+    let _deleteOldLogs_decorators;
+    return class ConsoleLogsTable extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _initializeLogCleanup_decorators = [(0, orm_1.ProxyClientTableMethodCalls)()];
+            _deleteOldLogs_decorators = [(0, orm_1.ProxyClientTableMethodCalls)()];
+            __esDecorate(this, null, _initializeLogCleanup_decorators, { kind: "method", name: "initializeLogCleanup", static: false, private: false, access: { has: obj => "initializeLogCleanup" in obj, get: obj => obj.initializeLogCleanup }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _deleteOldLogs_decorators, { kind: "method", name: "deleteOldLogs", static: false, private: false, access: { has: obj => "deleteOldLogs" in obj, get: obj => obj.deleteOldLogs }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        LOG_TTL = (__runInitializers(this, _instanceExtraInitializers), 7 * 24 * 60 * 60 * 1000); // 7 days
+        LOG_CLEANUP_INTERVAL = 24 * 60 * 60 * 1000; // 1 day
+        constructor(metaData, deps) {
+            super(metaData, deps);
+            if (typeof process !== 'undefined' && process.env.NODE_ENV !== 'test') {
+                this.initializeLogCleanup();
+            }
+        }
+        logCleanupInitialized = false;
+        async initializeLogCleanup() {
+            if (this.logCleanupInitialized) {
+                return;
+            }
+            this.logCleanupInitialized = true;
+            // always cleanup old logs on startup - randomly spread out of the first 60 seconds to not slam the db
+            setTimeout(() => this.deleteOldLogs(), 60_000 * Math.random());
+            // regularly clean up logs 
+            // TODO - consider doing this as a workflow
+            setInterval(() => this.deleteOldLogs(), this.LOG_CLEANUP_INTERVAL);
+        }
+        async deleteOldLogs(cutoffTimestamp = Date.now() - 7 * 24 * 60 * 60 * 1000) {
+            const count = await this.count({ timestamp: { $lt: cutoffTimestamp } });
+            if (count === 0) {
+                console.log(`No old logs to clean up older than ${new Date(cutoffTimestamp).toISOString()}`);
+                return;
+            }
+            let ds = this.dataSource;
+            while (!(ds instanceof orm_1.SQLDataSource) && ds.dataSource) {
+                ds = ds.dataSource;
+            }
+            if (ds instanceof orm_1.SQLDataSource) {
+                const db = ds.db;
+                await db.exec(`delete from ConsoleLogs where timestamp < $timestamp`, { timestamp: cutoffTimestamp });
+                console.log(`bulk deleted ${count} logs`);
+            }
+            else {
+                const cursor = this.cursor({ timestamp: { $lt: cutoffTimestamp } }, { sortBy: ['-timestamp'] });
+                let count2 = 0;
+                for await (const log of cursor) {
+                    this.delete(log.logId);
+                }
+                console.log(`cursor deleted ${count2} logs`);
+            }
+            console.log(`cleaned up console logs`, { expectedCount: count });
+        }
+    };
+})();
+exports.ConsoleLogsTable = ConsoleLogsTable;
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.consoleLogSchema, ConsoleLogsTable);
+/**
+ * We always use the user's personal data context so all logs are written to the same place.  This requires
+ * that the table be accessed in an asynchronous way
+ */
+async function ConsoleLogs() {
+    const userContext = await (0, user_context_singleton_1.getUserContext)();
+    return (0, user_context_singleton_1.getTableContainer)(userContext.userDataContext).getTable(metaData, exports.consoleLogSchema, ConsoleLogsTable);
+}

package/dist/logging/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./console-logger";
+export * from "./console-logs.table";

package/dist/logging/index.js

@@ -0,0 +1,18 @@
+"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("./console-logger"), exports);
+__exportStar(require("./console-logs.table"), exports);

package/dist/rpc-types.js

@@ -16,7 +16,6 @@ exports.rpcServerCalls = {
     setUserIdAndSecretKey: rpcStub('setUserIdAndSecretKey'),
     getUserId: rpcStub('getUserId'),
     encryptData: rpcStub('encryptData'),
-    // TODO collapse these all down to just tableMethodCall
     tableMethodCall: rpcStub('tableMethodCall'),
     // TODO lock this down so not all code can get any file contents
     getFileContents: rpcStub('getFileContents'),

package/dist/types/peer-device.d.ts

@@ -7,6 +7,16 @@ export interface IPeerDevice {
     listChanges(filter?: DataFilter<IChange>, opts?: IDataQueryParams<IChange>): Promise<IChange[]>;
     getNetworkInfo(): Promise<INetworkInfo>;
     notifyOfChanges(deviceId: string, timestampLastApplied: number): Promise<void>;
+    sendDeviceMessage(message: IDeviceMessage): Promise<any>;
+}
+export interface IDeviceMessage {
+    deviceMessageId: string;
+    fromDeviceId: string;
+    toDeviceId: string;
+    dataContextId: string;
+    ttl: number;
+    payload: any;
+    signature: string;
 }
 export interface INetworkInfo {
     deviceId: string;

package/package.json

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