@peers-app/peers-sdk 0.7.2 → 0.7.5

package/dist/data/users.d.ts

@@ -1,33 +1,33 @@
 import { z } from "zod";
 import type { DataContext } from "../context/data-context";
-import { TrustLevel } from "../device/socket.type";
-import { ISaveOptions, Table } from "./orm";
+import type { ISaveOptions } from "./orm/data-query";
+import { Table } from "./orm/table";
 export declare const userSchema: z.ZodObject<{
     userId: z.ZodString;
     name: z.ZodString;
     publicKey: z.ZodString;
     publicBoxKey: z.ZodString;
-    trustLevel: z.ZodOptional<z.ZodNativeEnum<typeof TrustLevel>>;
     signature: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     name: string;
     publicKey: string;
-    publicBoxKey: string;
     userId: string;
+    publicBoxKey: string;
     signature?: string | undefined;
-    trustLevel?: TrustLevel | undefined;
 }, {
     name: string;
     publicKey: string;
-    publicBoxKey: string;
     userId: string;
+    publicBoxKey: string;
     signature?: string | undefined;
-    trustLevel?: TrustLevel | undefined;
 }>;
 export type IUser = z.infer<typeof userSchema>;
 export declare class UsersTable extends Table<IUser> {
     static isPassthrough: boolean;
     save(user: IUser, opts?: ISaveOptions): Promise<IUser>;
+    signAndSave(user: IUser, opts?: ISaveOptions): Promise<IUser>;
+    private static addSignatureToUser;
+    static enableUserSigning(fn: (user: IUser) => IUser): void;
     /** @deprecated Forbidden on UsersTable; use save() */
     insert(..._args: Parameters<Table<IUser>['insert']>): never;
     /** @deprecated Forbidden on UsersTable; use save() */

package/dist/data/users.js

@@ -1,22 +1,55 @@
 "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.myUserId = exports.UsersTable = exports.userSchema = void 0;
 exports.Users = Users;
 exports.getMe = getMe;
 const zod_1 = require("zod");
 const user_context_singleton_1 = require("../context/user-context-singleton");
-const socket_type_1 = require("../device/socket.type");
-const orm_1 = require("./orm");
+const decorators_1 = require("./orm/decorators");
+const table_1 = require("./orm/table");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
 const types_1 = require("./orm/types");
-const user_permissions_1 = require("./user-permissions");
 const persistent_vars_1 = require("./persistent-vars");
+const user_permissions_1 = require("./user-permissions");
 exports.userSchema = zod_1.z.object({
     userId: zod_1.z.string(),
     name: zod_1.z.string(),
     publicKey: zod_1.z.string().describe('The public key the user uses to sign messages'),
     publicBoxKey: zod_1.z.string().describe('The public key to use to encrypt data that only this user can decrypt'),
-    trustLevel: zod_1.z.nativeEnum(socket_type_1.TrustLevel).optional().describe('The trust level of the user'),
     signature: zod_1.z.string().optional().describe('The signed hash of this user object excluding the signature itself'),
 });
 const metaData = {
@@ -30,32 +63,58 @@ const metaData = {
         { fields: ['publicBoxKey'] },
     ]
 };
-class UsersTable extends orm_1.Table {
-    static isPassthrough = false;
-    async save(user, opts) {
-        if (UsersTable.isPassthrough) {
-            return super.save(user, opts);
+let UsersTable = (() => {
+    let _classSuper = table_1.Table;
+    let _instanceExtraInitializers = [];
+    let _signAndSave_decorators;
+    return class UsersTable extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _signAndSave_decorators = [(0, decorators_1.ProxyClientTableMethodCalls)()];
+            __esDecorate(this, null, _signAndSave_decorators, { kind: "method", name: "signAndSave", static: false, private: false, access: { has: obj => "signAndSave" in obj, get: obj => obj.signAndSave }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        const userContext = await (0, user_context_singleton_1.getUserContext)();
-        const userContextUserTable = Users(userContext.userDataContext);
-        if (this === userContextUserTable) {
-            // user is allowed to make any changes they want to their own user table
+        static isPassthrough = false;
+        async save(user, opts) {
+            if (UsersTable.isPassthrough) {
+                return super.save(user, opts);
+            }
+            const userContext = await (0, user_context_singleton_1.getUserContext)();
+            const userContextUserTable = Users(userContext.userDataContext);
+            if (this === userContextUserTable) {
+                // user is allowed to make any changes they want to their own user table
+                return super.save(user, opts);
+            }
+            // Get the old user record if it exists
+            const oldUser = await this.get(user.userId);
+            await (0, user_permissions_1.verifyUserSignature)(user, oldUser);
             return super.save(user, opts);
         }
-        // Get the old user record if it exists
-        const oldUser = await this.get(user.userId);
-        await (0, user_permissions_1.verifyUserSignature)(user, oldUser);
-        return super.save(user, opts);
-    }
-    /** @deprecated Forbidden on UsersTable; use save() */
-    insert(..._args) {
-        throw new Error('UsersTable forbids insert; use save()');
-    }
-    /** @deprecated Forbidden on UsersTable; use save() */
-    update(..._args) {
-        throw new Error('UsersTable forbids update; use save()');
-    }
-}
+        async signAndSave(user, opts) {
+            if (!UsersTable.addSignatureToUser) {
+                throw new Error('User signing must be enabled to sign and save users. Call UsersTable.enableUserSigning(fn) to enable it.');
+            }
+            user = UsersTable.addSignatureToUser(user);
+            return this.save(user, opts);
+        }
+        static addSignatureToUser = undefined;
+        static enableUserSigning(fn) {
+            UsersTable.addSignatureToUser = fn;
+        }
+        /** @deprecated Forbidden on UsersTable; use save() */
+        insert(..._args) {
+            throw new Error('UsersTable forbids insert; use save()');
+        }
+        /** @deprecated Forbidden on UsersTable; use save() */
+        update(..._args) {
+            throw new Error('UsersTable forbids update; use save()');
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+})();
 exports.UsersTable = UsersTable;
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.userSchema, UsersTable);
 function Users(dataContext) {

package/dist/data/workflow-logs.d.ts

@@ -66,7 +66,7 @@ export declare const workflowLogSchema: z.ZodObject<{
     isError?: boolean | undefined;
 }>;
 export type IWorkflowLog = z.infer<typeof workflowLogSchema>;
-export declare function WorkflowLogs(dataContext?: DataContext): import("..").Table<{
+export declare function WorkflowLogs(dataContext?: DataContext): import("./orm").Table<{
     workflowLogId: string;
     workflowRunId: string;
     contextId: string;

package/dist/data/workflow-runs.js

@@ -93,7 +93,7 @@ let WorkflowRunTable = (() => {
     return class WorkflowRunTable extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
-            _haltRun_decorators = [(0, orm_1.ProxyClientCalls)()];
+            _haltRun_decorators = [(0, orm_1.ProxyClientTableMethodCalls)()];
             __esDecorate(this, null, _haltRun_decorators, { kind: "method", name: "haltRun", static: false, private: false, access: { has: obj => "haltRun" in obj, get: obj => obj.haltRun }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }

package/dist/data/workflows.d.ts

@@ -1,5 +1,5 @@
 import type { DataContext } from "../context/data-context";
-export declare function Workflows(dataContext?: DataContext): import("..").Table<{
+export declare function Workflows(dataContext?: DataContext): import("./orm").Table<{
     name: string;
     description: string;
     createdAt: Date;

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

@@ -15,16 +15,17 @@ function getTrustLevelFn(me, serverUrl) {
             return socket_type_1.TrustLevel.Trusted;
         }
         // await Devices().delete(deviceInfo.deviceId);
-        let [user, device] = await Promise.all([
+        let [user, device, userTrustLevel] = await Promise.all([
             (0, data_1.Users)(userDataContext).get(deviceInfo.userId),
             (0, data_1.Devices)(userDataContext).get(deviceInfo.deviceId),
+            (0, data_1.UserTrustLevels)(userDataContext).get(deviceInfo.userId),
         ]);
         if (user && device && !(deviceInfo.userId === device.userId && deviceInfo.userId === user.userId && deviceInfo.publicKey === user.publicKey && deviceInfo.publicBoxKey === user.publicBoxKey)) {
             console.error(new Date().toISOString(), 'deviceInfo does not align with local info about user and device', { deviceInfo, user, device });
             // TODO check if user has changed their public keys
             return socket_type_1.TrustLevel.Untrusted;
         }
-        if (user?.trustLevel && user.trustLevel >= socket_type_1.TrustLevel.Trusted && device?.trustLevel && device.trustLevel >= socket_type_1.TrustLevel.Trusted) {
+        if (userTrustLevel?.trustLevel && userTrustLevel.trustLevel >= socket_type_1.TrustLevel.Trusted && device?.trustLevel && device.trustLevel >= socket_type_1.TrustLevel.Trusted) {
             device.lastSeen = new Date();
             await (0, data_1.Devices)(userDataContext).update(device);
             return socket_type_1.TrustLevel.Trusted;
@@ -63,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;
@@ -76,9 +77,12 @@ function getTrustLevelFn(me, serverUrl) {
         //     }
         //   }
         // }
-        if (remoteTrustLevel > socket_type_1.TrustLevel.Unknown && !user.trustLevel) {
-            user.trustLevel = socket_type_1.TrustLevel.Known;
-            await (0, data_1.Users)(userDataContext).save(user);
+        if (remoteTrustLevel > socket_type_1.TrustLevel.Unknown && !userTrustLevel) {
+            await (0, data_1.UserTrustLevels)(userDataContext).save({
+                userId: deviceInfo.userId,
+                trustLevel: socket_type_1.TrustLevel.Known,
+                assignedAt: new Date(),
+            });
         }
         else if (newUser) {
             await (0, data_1.Users)(userDataContext).save(user);

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>;