@peers-app/peers-sdk 0.1.4

package/dist/data/workflow-runs.js

@@ -0,0 +1,313 @@
+"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.workflowRunSchema = void 0;
+exports.WorkflowRuns = WorkflowRuns;
+exports.runWorkflow = runWorkflow;
+const moment = require("moment-timezone");
+const channels_1 = require("./channels");
+const groups_1 = require("./groups");
+const messages_1 = require("./messages");
+const table_1 = require("./orm/table");
+const types_1 = require("./orm/types");
+const users_1 = require("./users");
+const workflow_logs_1 = require("./workflow-logs");
+const workflows_1 = require("./workflows");
+const utils_1 = require("../utils");
+const mentions_1 = require("../mentions");
+const user_context_singleton_1 = require("../context/user-context-singleton");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const zod_1 = require("zod");
+const workflow_1 = require("../types/workflow");
+const zod_types_1 = require("../types/zod-types");
+const data_locks_1 = require("./data-locks");
+const assistants_1 = require("./assistants");
+const system_ids_1 = require("../system-ids");
+const orm_1 = require("./orm");
+exports.workflowRunSchema = zod_1.z.object({
+    workflowRunId: zod_types_1.zodPeerId,
+    workflowId: zod_types_1.zodPeerId.optional().describe('The workflow that is being run. '),
+    parentMessageId: zod_types_1.zodPeerId.describe('The message that this workflow will run in the context of'),
+    createdAt: zod_1.z.date().default(() => new Date()).describe('The date the workflow run was created'),
+    scheduleDT: zod_1.z.date().optional().describe('The date and time that the workflow run is scheduled to run'),
+    instructions: workflow_1.workflowInstructionSchema.array().default([]).describe('The remaining instructions that still need to be done.  The LLM can use this as a scratch pad, adding and removing instructions as needed.'),
+    currentInstructionIndex: zod_1.z.number().default(0).describe('The index of the current instruction that is being run'),
+    instructionResults: zod_1.z.any().array().default([]).describe('The results of the instructions that have been run.'),
+    inErrorState: zod_1.z.boolean().optional().describe('Whether or not the workflow run is in an error state'),
+    startedAt: zod_1.z.date().optional().describe('The date the workflow run first started to be processed'),
+    completedAt: zod_1.z.date().optional().describe('The date the workflow run was completed'),
+    vars: zod_types_1.zodAnyObject.default(() => ({})).describe(`The current value of the workflow run.  This is a scratch pad that the LLM can use to store values that are needed for the workflow run.`),
+    parentWorkflowRunId: zod_types_1.zodPeerId.optional().describe('The parent workflow run id if this is a sub workflow run'),
+    defaultAssistantId: zod_types_1.zodPeerId.describe('The default assistant to use for this workflow run'),
+});
+const metaData = {
+    name: 'WorkflowRuns',
+    description: 'workflows instances that have been run manually, from messages, or from events',
+    primaryKeyName: 'workflowRunId',
+    fields: (0, types_1.schemaToFields)(exports.workflowRunSchema),
+    indexes: [
+        { fields: ['workflowId'], },
+        { fields: ['parentMessageId'], },
+        { fields: ['parentWorkflowRunId'], },
+        { fields: ['completedAt'], },
+        { fields: ['inErrorState'], },
+    ],
+};
+let WorkflowRunTable = (() => {
+    let _classSuper = table_1.Table;
+    let _instanceExtraInitializers = [];
+    let _haltRun_decorators;
+    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)()];
+            __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 });
+        }
+        /** @deprecated Direct calls to save forbidden; use insert or saveWithLock */
+        save(..._args) {
+            throw new Error('Direct inserts forbidden; use insert() or saveWithLock()');
+        }
+        /** @deprecated Direct calls to update forbidden; use saveWithLock() */
+        update(..._args) {
+            throw new Error('Direct updates forbidden; use saveWithLock()');
+        }
+        async saveWithLock(workflowRun, lock) {
+            if (!workflowRun.workflowRunId) {
+                workflowRun.workflowRunId = (0, utils_1.newid)();
+                return super.insert(workflowRun);
+            }
+            let lockedForThisSave = false;
+            if (!lock) {
+                lock = await (0, data_locks_1.DataLocks)().acquireLock(workflowRun.workflowRunId);
+                lockedForThisSave = true;
+            }
+            else {
+                const currentLock = await (0, data_locks_1.DataLocks)().getCurrentLock(workflowRun.workflowRunId);
+                if (currentLock?.dataLockId !== lock.dataLockId) {
+                    throw new Error(`Provided lock is not the current lock for workflowRunId ${workflowRun.workflowRunId} - aborting save`);
+                }
+            }
+            if (!lock) {
+                throw new Error(`Could not acquire lock for workflow run ${workflowRun.workflowRunId}`);
+            }
+            if (lock.recordId !== workflowRun.workflowRunId) {
+                throw new Error(`Provided lock recordId ${lock?.recordId} does not match workflowRunId ${workflowRun.workflowRunId}`);
+            }
+            let dbData = await this.get(workflowRun.workflowRunId);
+            if (dbData && !lock) {
+                const currentLock = await (0, data_locks_1.DataLocks)().getCurrentLock(workflowRun.workflowRunId);
+                if (currentLock) {
+                    throw new Error(`Workflow run ${workflowRun.workflowRunId} is locked by ${currentLock.dataLockId} - the lock will timeout at ${new Date(currentLock.lockedUntil)}`);
+                }
+            }
+            if (dbData?.inErrorState) {
+                throw new Error(`Workflow run ${workflowRun.workflowRunId} is in an error state - use clearErrorState to continue the run`);
+            }
+            if (dbData) {
+                dbData = await super.update(workflowRun);
+            }
+            else {
+                dbData = await super.insert(workflowRun);
+            }
+            if (lockedForThisSave) {
+                await (0, data_locks_1.DataLocks)().releaseLock(lock);
+            }
+            return dbData;
+        }
+        async acquireLock(workflowRunId, timeoutMs, lockTimeMs) {
+            const workflowDbData = await this.get(workflowRunId);
+            if (!workflowDbData)
+                return undefined;
+            if (workflowDbData.inErrorState) {
+                console.warn(`Workflow run ${workflowRunId} is in an error state - not acquiring lock`);
+                return undefined;
+            }
+            return await (0, data_locks_1.DataLocks)().acquireLock(workflowRunId, timeoutMs, lockTimeMs);
+        }
+        async saveAndRelease(workflowRun, lock) {
+            const workflowDbData = await this.get(workflowRun.workflowRunId);
+            if (!workflowDbData)
+                return;
+            const currentLock = await (0, data_locks_1.DataLocks)().getCurrentLock(workflowRun.workflowRunId);
+            if (!currentLock || currentLock.dataLockId !== lock.dataLockId) {
+                console.warn(`Workflow run ${workflowRun.workflowRunId} is not locked by ${lock.dataLockId} - aborting save`);
+                return;
+            }
+            if (workflowDbData.inErrorState) {
+                console.warn(`Workflow run ${workflowRun.workflowRunId} is in an error state - aborting save`);
+                return;
+            }
+            await super.update(workflowRun);
+            await (0, data_locks_1.DataLocks)().releaseLock(lock);
+        }
+        async haltRun(workflowRunId) {
+            const run = await super.get(workflowRunId);
+            if (!run) {
+                throw new Error(`Workflow run ${workflowRunId} not found`);
+            }
+            if (run.inErrorState) {
+                console.warn(`Workflow run ${workflowRunId} is already in an error state - not halting`);
+                return;
+            }
+            if (!run.completedAt) {
+                run.inErrorState = true;
+                await super.update(run);
+                // Release any existing lock
+                while (true) {
+                    const currentLock = await (0, data_locks_1.DataLocks)().getCurrentLock(workflowRunId);
+                    if (currentLock) {
+                        await (0, data_locks_1.DataLocks)().releaseLock(currentLock);
+                    }
+                    else {
+                        break; // No lock to release
+                    }
+                }
+                // also halt any child runs
+                this.list({ parentWorkflowRunId: workflowRunId }).then(async (childRuns) => {
+                    childRuns.forEach(async (child) => {
+                        this.haltRun(child.workflowRunId).catch((err) => console.error(`Error halting child run ${child.workflowRunId}`, err));
+                    });
+                }).catch((err) => console.error(`Error halting child runs for ${workflowRunId}`, err));
+                // send message and log
+                const runHaltMessage = `Workflow run canceled at ${new Date().toISOString()}`;
+                await (0, messages_1.sendMessage)({
+                    channelOrThreadIdOrWorkflowRunId: run.parentMessageId,
+                    assistantId: run.defaultAssistantId,
+                    messageContent: runHaltMessage,
+                });
+                const logger = (0, workflow_logs_1.getLogger)(run.workflowRunId, (0, utils_1.newid)());
+                logger(runHaltMessage);
+            }
+        }
+        /**
+         * Removes the error state from a workflow run and locks it so
+         * additional editing can be done before it is re-run.
+         */
+        async clearErrorState(workflowRunId) {
+            const run = await super.get(workflowRunId);
+            if (!run) {
+                throw new Error(`Workflow run ${workflowRunId} not found`);
+            }
+            if (!run.inErrorState) {
+                console.warn(`Workflow run ${workflowRunId} is not in an error state - not clearing`);
+                return false;
+            }
+            const lock = await (0, data_locks_1.DataLocks)().acquireLock(workflowRunId);
+            if (!lock) {
+                console.warn(`Could not acquire lock for workflow run ${workflowRunId}`);
+                return false;
+            }
+            run.inErrorState = false;
+            await super.update(run);
+            return lock;
+        }
+        constructor() {
+            super(...arguments);
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+})();
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.workflowRunSchema, WorkflowRunTable);
+function WorkflowRuns(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, exports.workflowRunSchema);
+}
+async function runWorkflow(args) {
+    const { workflowId, parentWorkflowRunId, vars } = args;
+    // TODO determine what dataContext this is for 
+    const workflow = await (0, workflows_1.Workflows)().get(workflowId);
+    if (!workflow) {
+        throw new Error(`Workflow ${workflowId} not found`);
+    }
+    const me = await (0, users_1.getMe)();
+    const assistantId = workflow.defaultAssistantId
+        || (await (0, assistants_1.getPrimaryAssistant)()).assistantId
+        || system_ids_1.defaultAssistantId;
+    let parentMessageId = '';
+    let channelId = '';
+    if (args.parentMessageIdOrChannelIdOrGroupId) {
+        let message = await (0, messages_1.Messages)().get(args.parentMessageIdOrChannelIdOrGroupId);
+        if (message) {
+            parentMessageId = message.messageId;
+            channelId = message.channelId;
+        }
+        else {
+            channelId = args.parentMessageIdOrChannelIdOrGroupId;
+            const channel = await (0, channels_1.Channels)().get(args.parentMessageIdOrChannelIdOrGroupId);
+            if (!channel) {
+                const group = await (0, groups_1.Groups)().get(args.parentMessageIdOrChannelIdOrGroupId);
+                if (!group) {
+                    throw new Error(`Message, channel, or group ${args.parentMessageIdOrChannelIdOrGroupId} not found`);
+                }
+                channelId = group.groupId;
+            }
+        }
+    }
+    const workflowRunId = (0, utils_1.newid)();
+    const workflowMention = (0, mentions_1.formatMention)({ kind: 'workflow', id: workflowId, name: workflow.name });
+    let messageContent = `Running workflow ${workflowMention}`;
+    if (!parentMessageId) {
+        if (!channelId) {
+            channelId = me.userId;
+        }
+        if (args.scheduleDT) {
+            messageContent = `Scheduled workflow ${workflowMention} for ${moment(args.scheduleDT).calendar()} (\`${args.scheduleDT.toISOString()}\`)`;
+        }
+        const message = await (0, messages_1.sendMessage)({
+            channelOrThreadIdOrWorkflowRunId: channelId,
+            assistantId,
+            messageContent,
+        });
+        parentMessageId = message.messageId;
+    }
+    else {
+        (0, workflow_logs_1.getLogger)(workflowRunId, (0, utils_1.newid)())(messageContent);
+    }
+    const run = await WorkflowRuns().insert({
+        workflowRunId,
+        createdAt: new Date(),
+        scheduleDT: args.scheduleDT,
+        workflowId,
+        parentMessageId,
+        instructions: workflow.instructions,
+        currentInstructionIndex: 0,
+        instructionResults: [],
+        defaultAssistantId: assistantId,
+        parentWorkflowRunId,
+        vars,
+    });
+    return run;
+}

package/dist/data/workflows.d.ts

@@ -0,0 +1,16 @@
+import type { DataContext } from "../context/data-context";
+export declare function Workflows(dataContext?: DataContext): import("./orm").Table<{
+    name: string;
+    description: string;
+    createdAt: Date;
+    workflowId: string;
+    defaultAssistantId: string;
+    instructions: {
+        markdown?: string | undefined;
+        onError?: string | undefined;
+        directCallToolId?: string | undefined;
+        subWorkflowId?: string | undefined;
+    }[];
+    createdBy: string;
+    updatedAt: Date;
+}>;

package/dist/data/workflows.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workflows = Workflows;
+const workflow_1 = require("../types/workflow");
+const types_1 = require("./orm/types");
+const user_context_singleton_1 = require("../context/user-context-singleton");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const metaData = {
+    name: 'Workflows',
+    description: 'workflows',
+    primaryKeyName: 'workflowId',
+    fields: (0, types_1.schemaToFields)(workflow_1.workflowSchema),
+    iconClassName: 'bi bi-database-fill-gear',
+    indexes: [
+        { fields: ['name'], },
+    ],
+};
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, workflow_1.workflowSchema);
+function Workflows(dataContext) {
+    return (0, user_context_singleton_1.getTableContainer)(dataContext).getTable(metaData, workflow_1.workflowSchema);
+}

package/dist/device/connection.d.ts

@@ -0,0 +1,41 @@
+import { IDataBox } from "../keys";
+import { Device } from "./device";
+import { IDeviceHandshake, IDeviceInfo } from "../data";
+import { ISocket, TrustLevel } from "./socket.type";
+export type GetTrustLevel = (deviceInfo: IDeviceInfo, registerNew?: boolean) => Promise<TrustLevel>;
+export declare class Connection {
+    readonly localDevice: Device;
+    readonly localDeviceServerAddresses?: string[] | undefined;
+    protected readonly getTrustLevel: GetTrustLevel;
+    private _verified;
+    private _remoteDeviceInfo;
+    secureLocal: boolean;
+    secureRemote: boolean;
+    forceInsecure: boolean;
+    trustLevel: TrustLevel;
+    onHandshakeComplete: ((deviceInfo: IDeviceInfo) => void) | undefined;
+    timeoutMs: number;
+    maxChunkSize: number;
+    handshakeTimestampToleranceMs: number;
+    readonly socket: ISocket;
+    constructor(socket: ISocket, localDevice: Device, localDeviceServerAddresses?: string[] | undefined, getTrustLevel?: GetTrustLevel);
+    get verified(): boolean;
+    get secure(): boolean;
+    get remoteDeviceInfo(): {
+        userId: string;
+        deviceId: string;
+        publicKey: string;
+        publicBoxKey: string;
+    };
+    get connectionId(): string;
+    exposeRPC<T extends Function>(name: string, fn: T): void;
+    exposeRPC<T extends Function>(fn: T): void;
+    emit<T = any>(eventName: string, ...args: any): Promise<T>;
+    on(eventName: string, handler: Function): void;
+    removeAllListeners(eventName: string): void;
+    reset(): void;
+    initiateHandshake(serverAddress: string, remoteDeviceInfo?: IDeviceInfo): IDataBox;
+    completeHandshake(boxedHandshake: IDataBox): Promise<IDeviceHandshake>;
+    doHandshake(remoteAddress: string): Promise<IDeviceHandshake>;
+}
+export declare function normalizeAddress(address: string): string;

package/dist/device/connection.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Connection = void 0;
+exports.normalizeAddress = normalizeAddress;
+const utils_1 = require("../utils");
+const keys_1 = require("../keys");
+const socket_type_1 = require("./socket.type");
+const streamed_socket_1 = require("./streamed-socket");
+const HANDSHAKE_TIMESTAMP_TOLERANCE_MS = 300_000; // 5 minutes
+class Connection {
+    localDevice;
+    localDeviceServerAddresses;
+    getTrustLevel;
+    _verified = false;
+    _remoteDeviceInfo = {
+        deviceId: '',
+        userId: '',
+        publicKey: '',
+        publicBoxKey: '',
+    };
+    secureLocal = false;
+    secureRemote = false;
+    // TODO this concept of insecure needs to be adjusted
+    // what it actually means is that the underlying connection _is_ secure
+    // OR that both the client and server want to skip encryption (which we maybe shouldn't allow)
+    // webRTC connections _are_ secure so we'll be setting `forceInsecure` to true (which is a misnomer)
+    forceInsecure = false;
+    trustLevel = socket_type_1.TrustLevel.Unknown;
+    onHandshakeComplete;
+    timeoutMs = 60_000; // 60 seconds
+    maxChunkSize = socket_type_1.DEFAULT_MAX_CHUNK_SIZE;
+    handshakeTimestampToleranceMs = HANDSHAKE_TIMESTAMP_TOLERANCE_MS;
+    socket;
+    constructor(socket, localDevice, localDeviceServerAddresses, getTrustLevel = () => Promise.resolve(socket_type_1.TrustLevel.Unknown)) {
+        this.localDevice = localDevice;
+        this.localDeviceServerAddresses = localDeviceServerAddresses;
+        this.getTrustLevel = getTrustLevel;
+        this.localDeviceServerAddresses = localDeviceServerAddresses?.map(normalizeAddress);
+        // this.socket = socket;
+        this.socket = new streamed_socket_1.StreamedSocket(socket, this.maxChunkSize);
+        if (!socket.id) {
+            socket.id = (0, utils_1.newid)();
+        }
+        // Only the server side of a connection should expose these methods
+        if (localDeviceServerAddresses) {
+            this.exposeRPC('reset', this.reset.bind(this));
+            this.exposeRPC('getTrustLevel', async (deviceInfo) => {
+                const trustLevel = await this.getTrustLevel(deviceInfo, false);
+                console.log(`Sending client trust level ${trustLevel}`);
+                return trustLevel;
+            });
+            this.exposeRPC('requestDeviceInfo', this.localDevice.getDeviceInfo.bind(this.localDevice));
+            this.exposeRPC('completeHandshake', async (handshakeBox) => {
+                const handshakeResponse = await this.completeHandshake(handshakeBox);
+                return handshakeResponse;
+            });
+            this.exposeRPC('requestSecure', () => {
+                this.secureRemote = true;
+                return this.secure;
+            });
+        }
+    }
+    get verified() {
+        return this._verified;
+    }
+    get secure() {
+        if (this.forceInsecure) {
+            return false;
+        }
+        return this.secureLocal && this.secureRemote;
+    }
+    get remoteDeviceInfo() {
+        return { ...this._remoteDeviceInfo };
+    }
+    get connectionId() {
+        return this.socket.id || '';
+    }
+    exposeRPC(fn, name) {
+        if (typeof name === 'function') {
+            const _fn = name;
+            // @ts-ignore
+            name = fn;
+            fn = _fn;
+        }
+        name = name || fn.name;
+        this.on(name, async (...args) => {
+            return fn(...args);
+        });
+    }
+    emit(eventName, ...args) {
+        return new Promise((resolve, reject) => {
+            try {
+                if (this._verified && !this.secure) {
+                    args = this.localDevice.signAndBoxDataForDevice(args, this._remoteDeviceInfo);
+                }
+                const timeoutMs = this.timeoutMs;
+                const timeoutPid = setTimeout(() => {
+                    reject(`${eventName} timed out after ${timeoutMs}ms`);
+                }, timeoutMs);
+                this.socket.emit(eventName, args, (err, result) => {
+                    try {
+                        clearTimeout(timeoutPid);
+                        if (err) {
+                            err = this.localDevice.unwrapResponse(err);
+                            return reject(err);
+                        }
+                        if (eventName === 'requestSecure') {
+                            this.secureRemote = this.localDevice.unwrapResponse(result);
+                            result = this.secureRemote;
+                        }
+                        else if (this._verified && !this.secure) {
+                            // this purposely results in an error if the client is not securing the data when it should be
+                            result = this.localDevice.openBoxedAndSignedData(result);
+                        }
+                        resolve(result);
+                    }
+                    catch (e) {
+                        console.error(`Error connection.emit callback for ${eventName}(${JSON.stringify(args)})`, e);
+                        return reject(e);
+                    }
+                });
+            }
+            catch (e) {
+                console.error(`Error connection.emit for ${eventName}(${JSON.stringify(args)})`, e);
+                return reject(e);
+            }
+        });
+    }
+    on(eventName, handler) {
+        const handshakeEvents = ['requestDeviceInfo', 'completeHandshake', 'reset', 'getTrustLevel'];
+        this.socket.on(eventName, async (args, callback) => {
+            if (!this.verified && !handshakeEvents.includes(eventName)) {
+                console.error(`Ignoring event from unverified connection: ${eventName}`);
+                return callback(`Connection not verified.  Handshake must be completed successfully before calling ${eventName}`);
+            }
+            let result;
+            try {
+                if (this._verified && !this.secure) {
+                    args = this.localDevice.openBoxedAndSignedData(args);
+                }
+                result = await handler(...args);
+                if (this._verified && !this.secure) {
+                    result = this.localDevice.signAndBoxDataForDevice(result, this._remoteDeviceInfo);
+                }
+                callback(null, result);
+            }
+            catch (e) {
+                console.error(`Error handling ${eventName}(${JSON.stringify(args)})`, e);
+                let rpcError = { error: e.message, errorType: 'RPC_ERROR' };
+                if (this._verified && !this.secure) {
+                    rpcError = this.localDevice.signAndBoxDataForDevice(rpcError, this._remoteDeviceInfo);
+                }
+                callback(rpcError);
+            }
+        });
+    }
+    removeAllListeners(eventName) {
+        this.socket.removeAllListeners(eventName);
+    }
+    reset() {
+        this._remoteDeviceInfo = {
+            deviceId: '',
+            userId: '',
+            publicKey: '',
+            publicBoxKey: '',
+        };
+        this._verified = false;
+        this.secureLocal = false;
+        this.secureRemote = false;
+        this.forceInsecure = false;
+        this.trustLevel = socket_type_1.TrustLevel.Unknown;
+    }
+    initiateHandshake(serverAddress, remoteDeviceInfo) {
+        if (remoteDeviceInfo) {
+            this._remoteDeviceInfo = remoteDeviceInfo;
+        }
+        const handshake = this.localDevice.getHandshake(this.connectionId, serverAddress);
+        return this.localDevice.boxDataForDevice(handshake, this._remoteDeviceInfo);
+    }
+    async completeHandshake(boxedHandshake) {
+        const signedHandshake = this.localDevice.openBoxWithSecretKey(boxedHandshake);
+        const _handshake = signedHandshake.contents;
+        const timeDiff = Math.abs(Date.now() - _handshake.timestamp);
+        if (timeDiff > this.handshakeTimestampToleranceMs) {
+            throw new Error(`Remote device's system clock is too far out of sync`);
+        }
+        const clientServerAddress = normalizeAddress(signedHandshake.contents.serverAddress);
+        const thisServerAddress = this.localDeviceServerAddresses?.find(a => a === clientServerAddress) ||
+            this.localDeviceServerAddresses?.[0] ||
+            'unknown';
+        // only set local secure if the server address matches the client's address and the address is using https
+        this.secureLocal = clientServerAddress === thisServerAddress && thisServerAddress.startsWith('https');
+        const handshakeResponse = this.localDevice.handshakeResponse(signedHandshake, this.connectionId, thisServerAddress);
+        this._remoteDeviceInfo = {
+            userId: _handshake.userId,
+            deviceId: _handshake.deviceId,
+            publicKey: _handshake.publicKey,
+            publicBoxKey: _handshake.publicBoxKey,
+        };
+        this.trustLevel = await this.getTrustLevel(signedHandshake.contents, true);
+        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}`);
+        this._verified = true;
+        if (this.onHandshakeComplete) {
+            setTimeout(() => {
+                this.onHandshakeComplete?.(this._remoteDeviceInfo);
+            }, 10);
+        }
+        return handshakeResponse;
+    }
+    async doHandshake(remoteAddress) {
+        remoteAddress = normalizeAddress(remoteAddress);
+        this.reset();
+        await this.emit('reset');
+        const remoteDeviceInfoSigned = await this.emit('requestDeviceInfo');
+        const remoteDeviceInfo = (0, keys_1.openSignedObject)(remoteDeviceInfoSigned);
+        const handshake = await this.initiateHandshake(remoteAddress, remoteDeviceInfo);
+        const handshakeResponseBox = await this.emit('completeHandshake', handshake);
+        const handshakeResponse = await this.localDevice.openBoxedAndSignedData(handshakeResponseBox);
+        if (handshakeResponse.connectionId !== this.connectionId) {
+            throw new Error(`Invalid connectionId ${handshakeResponse.connectionId}, expected ${this.connectionId}`);
+        }
+        if (remoteDeviceInfo.publicKey != handshakeResponse.publicKey || remoteDeviceInfo.publicBoxKey != handshakeResponse.publicBoxKey) {
+            throw new Error('Inconsistent public keys');
+        }
+        if (remoteDeviceInfo.userId != handshakeResponse.userId || remoteDeviceInfo.deviceId != handshakeResponse.deviceId) {
+            throw new Error('Inconsistent device info');
+        }
+        this._verified = true;
+        this.secureLocal = handshakeResponse.serverAddress === remoteAddress && remoteAddress.startsWith('https');
+        if (this.secureLocal) {
+            await this.emit('requestSecure');
+        }
+        this.trustLevel = await this.getTrustLevel(remoteDeviceInfo, true);
+        if (this.trustLevel < socket_type_1.TrustLevel.Unknown) {
+            this.reset();
+            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}`);
+        return handshakeResponse;
+    }
+}
+exports.Connection = Connection;
+function normalizeAddress(address) {
+    return address.toLowerCase().replace(/\/$/, '');
+}

package/dist/device/connection.test.d.ts

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