@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/data/user-permissions.test.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const keys_1 = require("../keys");
 const user_permissions_1 = require("./user-permissions");
 // Test the user permissions logic directly without ORM dependencies
-describe('User Permissions Logic', () => {
+describe("User Permissions Logic", () => {
     let testUser;
     let userKeys;
     let otherUserKeys;
@@ -11,264 +11,266 @@ describe('User Permissions Logic', () => {
         userKeys = (0, keys_1.newKeys)();
         otherUserKeys = (0, keys_1.newKeys)();
         testUser = {
-            userId: 'test-user-1',
-            name: 'Test User',
+            userId: "test-user-1",
+            name: "Test User",
             publicKey: userKeys.publicKey,
             publicBoxKey: userKeys.publicBoxKey,
-            signature: ''
+            signature: "",
         };
     });
-    describe('basic signature functionality', () => {
-        it('should add signature to user object', () => {
+    describe("basic signature functionality", () => {
+        it("should add signature to user object", () => {
             const signedUser = (0, keys_1.addSignatureToObject)(testUser, userKeys.secretKey);
             expect(signedUser.signature).toBeTruthy();
-            expect(signedUser.signature).toContain(':');
+            expect(signedUser.signature).toContain(":");
             expect(signedUser.userId).toBe(testUser.userId);
             expect(signedUser.name).toBe(testUser.name);
             expect(signedUser.publicKey).toBe(testUser.publicKey);
         });
-        it('should verify valid signature', () => {
+        it("should verify valid signature", () => {
             const signedUser = (0, keys_1.addSignatureToObject)(testUser, userKeys.secretKey);
             const isValid = (0, keys_1.isObjectSignatureValid)(signedUser);
             expect(isValid).toBe(true);
         });
-        it('should reject invalid signature after modification', () => {
+        it("should reject invalid signature after modification", () => {
             const signedUser = (0, keys_1.addSignatureToObject)(testUser, userKeys.secretKey);
             // Modify the user after signing
-            signedUser.name = 'Modified Name';
+            signedUser.name = "Modified Name";
             const isValid = (0, keys_1.isObjectSignatureValid)(signedUser);
             expect(isValid).toBe(false);
         });
-        it('should extract public key from signature', () => {
+        it("should extract public key from signature", () => {
             const signedUser = (0, keys_1.addSignatureToObject)(testUser, userKeys.secretKey);
             const extractedPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedUser);
             expect(extractedPublicKey).toBe(userKeys.publicKey);
         });
     });
-    describe('signUserObject helper', () => {
-        it('should sign user object correctly', () => {
+    describe("signUserObject helper", () => {
+        it("should sign user object correctly", () => {
             const signedUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             expect(signedUser.signature).toBeTruthy();
             expect((0, keys_1.isObjectSignatureValid)(signedUser)).toBe(true);
             expect((0, keys_1.getPublicKeyFromObjectSignature)(signedUser)).toBe(userKeys.publicKey);
         });
     });
-    describe('verifyUserSignature', () => {
-        it('should verify valid signature for new user', () => {
+    describe("verifyUserSignature", () => {
+        it("should verify valid signature for new user", () => {
             const signedUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser)).not.toThrow();
         });
-        it('should verify valid signature for existing user update', () => {
+        it("should verify valid signature for existing user update", () => {
             const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             const updatedUser = {
                 ...originalUser,
-                name: 'Updated Name',
-                signature: ''
+                name: "Updated Name",
+                signature: "",
             };
             const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).not.toThrow();
         });
-        it('should reject signature that does not match user public key for new user', () => {
+        it("should reject signature that does not match user public key for new user", () => {
             const signedUser = (0, user_permissions_1.signUserObject)(testUser, otherUserKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser)).toThrow('User signature must be signed with their own public key');
+            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser)).toThrow("User signature must be signed with their own public key");
         });
-        it('should reject signature that does not match existing user public key', () => {
+        it("should reject signature that does not match existing user public key", () => {
             const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             const updatedUser = {
                 ...originalUser,
-                name: 'Updated Name',
-                signature: ''
+                name: "Updated Name",
+                signature: "",
             };
             const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, otherUserKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow('User update must be signed by the user themselves');
+            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow("User update must be signed by the user themselves");
         });
-        it('should reject public key changes', () => {
+        it("should reject public key changes", () => {
             const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             const updatedUser = {
                 ...originalUser,
                 publicKey: otherUserKeys.publicKey,
-                signature: ''
+                signature: "",
             };
             const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
-            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow('Public key changes are not currently supported');
+            expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow("Public key changes are not currently supported");
         });
-        it('should allow missing signature when no existing record', () => {
+        it("should allow missing signature when no existing record", () => {
             const userWithoutSignature = { ...testUser };
             expect(() => (0, user_permissions_1.verifyUserSignature)(userWithoutSignature)).not.toThrow();
         });
     });
-    describe('verifyUserSignature - Group Context (With Signature)', () => {
-        it('should allow valid signature for new user in group context', () => {
+    describe("verifyUserSignature - Group Context (With Signature)", () => {
+        it("should allow valid signature for new user in group context", () => {
             const signedUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).not.toThrow();
         });
-        it('should allow valid signature for existing user update in group context', () => {
+        it("should allow valid signature for existing user update in group context", () => {
             const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             const updatedUser = {
                 ...originalUser,
-                name: 'Updated Name',
-                signature: ''
+                name: "Updated Name",
+                signature: "",
             };
             const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).not.toThrow();
         });
-        it('should reject invalid signature in group context', () => {
+        it("should reject invalid signature in group context", () => {
             const signedUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             // Tamper with the signature
-            signedUser.name = 'Tampered Name';
+            signedUser.name = "Tampered Name";
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).toThrow();
         });
-        it('should reject signature from wrong user for new user', () => {
+        it("should reject signature from wrong user for new user", () => {
             const signedUser = (0, user_permissions_1.signUserObject)(testUser, otherUserKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).toThrow();
         });
-        it('should reject signature from wrong user for existing user update', () => {
+        it("should reject signature from wrong user for existing user update", () => {
             const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             const updatedUser = {
                 ...originalUser,
-                name: 'Updated Name',
-                signature: ''
+                name: "Updated Name",
+                signature: "",
             };
             const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, otherUserKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow();
         });
-        it('should reject public key changes in group context', () => {
+        it("should reject public key changes in group context", () => {
             const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             const updatedUser = {
                 ...originalUser,
                 publicKey: otherUserKeys.publicKey, // Change public key
-                signature: ''
+                signature: "",
             };
             const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow();
         });
-        it('should allow changes with valid signature', () => {
+        it("should allow changes with valid signature", () => {
             const originalUser = (0, user_permissions_1.signUserObject)({ ...testUser }, userKeys.secretKey);
             const updatedUser = {
                 ...originalUser,
-                name: 'Updated Name',
-                signature: ''
+                name: "Updated Name",
+                signature: "",
             };
             const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).not.toThrow();
         });
     });
-    describe('verifyUserSignature - Signature Requirements', () => {
-        it('should allow unsigned record when no existing record', () => {
+    describe("verifyUserSignature - Signature Requirements", () => {
+        it("should allow unsigned record when no existing record", () => {
             const userWithoutSignature = { ...testUser };
             expect(() => (0, user_permissions_1.verifyUserSignature)(userWithoutSignature, undefined)).not.toThrow();
         });
-        it('should accept valid signature when signature is provided', () => {
+        it("should accept valid signature when signature is provided", () => {
             const signedUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).not.toThrow();
         });
-        it('should allow empty signature when no existing record', () => {
-            const userWithEmptySignature = { ...testUser, signature: '' };
+        it("should allow empty signature when no existing record", () => {
+            const userWithEmptySignature = { ...testUser, signature: "" };
             expect(() => (0, user_permissions_1.verifyUserSignature)(userWithEmptySignature, undefined)).not.toThrow();
         });
-        it('should reject whitespace-only signature (treated as a bad signature, not a stub)', () => {
-            const userWithWhitespaceSignature = { ...testUser, signature: '   ' };
+        it("should reject whitespace-only signature (treated as a bad signature, not a stub)", () => {
+            const userWithWhitespaceSignature = { ...testUser, signature: "   " };
             expect(() => (0, user_permissions_1.verifyUserSignature)(userWithWhitespaceSignature, undefined)).toThrow();
         });
     });
-    describe('verifyUserSignature - Unsigned stubs', () => {
-        it('should allow unsigned stub when no existing record', () => {
+    describe("verifyUserSignature - Unsigned stubs", () => {
+        it("should allow unsigned stub when no existing record", () => {
             const stub = { ...testUser, signature: undefined };
             expect(() => (0, user_permissions_1.verifyUserSignature)(stub)).not.toThrow();
         });
-        it('should allow unsigned stub to overwrite an existing unsigned stub', () => {
+        it("should allow unsigned stub to overwrite an existing unsigned stub", () => {
             const existingStub = { ...testUser, signature: undefined };
-            const incomingStub = { ...testUser, name: 'Updated Name', signature: undefined };
+            const incomingStub = { ...testUser, name: "Updated Name", signature: undefined };
             expect(() => (0, user_permissions_1.verifyUserSignature)(incomingStub, existingStub)).not.toThrow();
         });
-        it('should reject unsigned stub when a signed record already exists', () => {
+        it("should reject unsigned stub when a signed record already exists", () => {
             const signedExisting = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             const incomingStub = { ...testUser, signature: undefined };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(incomingStub, signedExisting))
-                .toThrow('Cannot overwrite a signed user record with an unsigned one');
+            expect(() => (0, user_permissions_1.verifyUserSignature)(incomingStub, signedExisting)).toThrow("Cannot overwrite a signed user record with an unsigned one");
         });
-        it('should reject unsigned stub with different keys when signed record exists', () => {
+        it("should reject unsigned stub with different keys when signed record exists", () => {
             const signedExisting = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
-            const incomingStub = { ...testUser, publicKey: otherUserKeys.publicKey, signature: undefined };
-            expect(() => (0, user_permissions_1.verifyUserSignature)(incomingStub, signedExisting))
-                .toThrow('Cannot overwrite a signed user record with an unsigned one');
+            const incomingStub = {
+                ...testUser,
+                publicKey: otherUserKeys.publicKey,
+                signature: undefined,
+            };
+            expect(() => (0, user_permissions_1.verifyUserSignature)(incomingStub, signedExisting)).toThrow("Cannot overwrite a signed user record with an unsigned one");
         });
-        it('should allow a signed record to replace an unsigned stub', () => {
+        it("should allow a signed record to replace an unsigned stub", () => {
             const existingStub = { ...testUser, signature: undefined };
             const signedIncoming = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedIncoming, existingStub)).not.toThrow();
         });
     });
-    describe('edge cases and error handling', () => {
-        it('should handle undefined user gracefully', () => {
-            // @ts-ignore - Testing edge case
+    describe("edge cases and error handling", () => {
+        it("should handle undefined user gracefully", () => {
+            // @ts-expect-error - Testing edge case
             expect(() => (0, user_permissions_1.verifyUserSignature)(undefined, undefined)).toThrow();
         });
-        it('should handle malformed signature', () => {
-            const userWithBadSignature = { ...testUser, signature: 'invalid-signature' };
+        it("should handle malformed signature", () => {
+            const userWithBadSignature = { ...testUser, signature: "invalid-signature" };
             expect(() => (0, user_permissions_1.verifyUserSignature)(userWithBadSignature, undefined)).toThrow();
         });
-        it('should handle missing public key in user object', () => {
-            const userWithoutPublicKey = { ...testUser, publicKey: '' };
+        it("should handle missing public key in user object", () => {
+            const userWithoutPublicKey = { ...testUser, publicKey: "" };
             const signedUser = (0, user_permissions_1.signUserObject)(userWithoutPublicKey, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).toThrow();
         });
-        it('should handle existing user with missing public key', () => {
-            const originalUser = { ...testUser, publicKey: '' };
-            const updatedUser = { ...testUser, name: 'Updated' };
+        it("should handle existing user with missing public key", () => {
+            const originalUser = { ...testUser, publicKey: "" };
+            const updatedUser = { ...testUser, name: "Updated" };
             const signedUpdatedUser = (0, user_permissions_1.signUserObject)(updatedUser, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdatedUser, originalUser)).toThrow();
         });
-        it('should handle various user values', () => {
+        it("should handle various user values", () => {
             const userWithValues = {
                 ...testUser,
-                name: 'Complex Name'
+                name: "Complex Name",
             };
             const signedUser = (0, user_permissions_1.signUserObject)(userWithValues, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUser, undefined)).not.toThrow();
         });
     });
-    describe('security scenarios', () => {
-        it('should prevent impersonation attacks', () => {
+    describe("security scenarios", () => {
+        it("should prevent impersonation attacks", () => {
             // Attacker tries to create a user record with victim's public key but signed with attacker's key
             const victimUser = {
-                userId: 'victim-user',
-                name: 'Victim User',
+                userId: "victim-user",
+                name: "Victim User",
                 publicKey: userKeys.publicKey, // Victim's public key
                 publicBoxKey: userKeys.publicBoxKey,
-                signature: ''
+                signature: "",
             };
             const maliciousSignedUser = (0, user_permissions_1.signUserObject)(victimUser, otherUserKeys.secretKey); // Signed with attacker's key
             expect(() => (0, user_permissions_1.verifyUserSignature)(maliciousSignedUser, undefined)).toThrow();
         });
-        it('should prevent profile takeover attacks', () => {
+        it("should prevent profile takeover attacks", () => {
             const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             // Attacker tries to update the user's profile with their own signature
             const maliciousUpdate = {
                 ...originalUser,
-                name: 'Attacker Name',
-                signature: ''
+                name: "Attacker Name",
+                signature: "",
             };
             const maliciousSignedUpdate = (0, user_permissions_1.signUserObject)(maliciousUpdate, otherUserKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(maliciousSignedUpdate, originalUser)).toThrow();
         });
-        it('should prevent public key rotation attacks', () => {
+        it("should prevent public key rotation attacks", () => {
             const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             // Attacker tries to change the public key to their own
             const keyRotationAttack = {
                 ...originalUser,
                 publicKey: otherUserKeys.publicKey, // Change to attacker's key
-                signature: ''
+                signature: "",
             };
             const signedAttack = (0, user_permissions_1.signUserObject)(keyRotationAttack, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedAttack, originalUser)).toThrow();
         });
-        it('should allow legitimate name changes with proper signature', () => {
+        it("should allow legitimate name changes with proper signature", () => {
             const originalUser = (0, user_permissions_1.signUserObject)(testUser, userKeys.secretKey);
             const legitimateUpdate = {
                 ...originalUser,
-                name: 'New Legal Name',
-                signature: ''
+                name: "New Legal Name",
+                signature: "",
             };
             const signedUpdate = (0, user_permissions_1.signUserObject)(legitimateUpdate, userKeys.secretKey);
             expect(() => (0, user_permissions_1.verifyUserSignature)(signedUpdate, originalUser)).not.toThrow();

package/dist/data/user-trust-levels.js

@@ -18,19 +18,19 @@ const types_1 = require("./orm/types");
  * Each context can maintain its own trust assessment of other users.
  */
 exports.userTrustLevelSchema = zod_1.z.object({
-    userId: zod_types_1.zodPeerId.describe('The user being assigned a trust level'),
-    trustLevel: zod_1.z.nativeEnum(socket_type_1.TrustLevel).describe('The trust level assigned to this user in this context'),
-    assignedAt: zod_1.z.date().optional().describe('When the trust level was assigned'),
-    notes: zod_1.z.string().optional().describe('Optional notes about why this trust level was assigned'),
+    userId: zod_types_1.zodPeerId.describe("The user being assigned a trust level"),
+    trustLevel: zod_1.z
+        .nativeEnum(socket_type_1.TrustLevel)
+        .describe("The trust level assigned to this user in this context"),
+    assignedAt: zod_1.z.date().optional().describe("When the trust level was assigned"),
+    notes: zod_1.z.string().optional().describe("Optional notes about why this trust level was assigned"),
 });
 const metaData = {
-    name: 'UserTrustLevels',
-    description: 'Trust levels assigned to users by the current context (user or group)',
-    primaryKeyName: 'userId',
+    name: "UserTrustLevels",
+    description: "Trust levels assigned to users by the current context (user or group)",
+    primaryKeyName: "userId",
     fields: (0, types_1.schemaToFields)(exports.userTrustLevelSchema),
-    indexes: [
-        { fields: ['trustLevel'] },
-    ]
+    indexes: [{ fields: ["trustLevel"] }],
 };
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.userTrustLevelSchema);
 function UserTrustLevels(dataContext) {

package/dist/data/users.d.ts

@@ -11,14 +11,14 @@ export declare const userSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     name: string;
     publicKey: string;
-    userId: string;
     publicBoxKey: string;
+    userId: string;
     signature?: string | undefined;
 }, {
     name: string;
     publicKey: string;
-    userId: string;
     publicBoxKey: string;
+    userId: string;
     signature?: string | undefined;
 }>;
 export type IUser = z.infer<typeof userSchema>;
@@ -29,9 +29,9 @@ export declare class UsersTable extends Table<IUser> {
     private static addSignatureToUser;
     static enableUserSigning(fn: (user: IUser) => IUser): void;
     /** @deprecated Forbidden on UsersTable; use save() */
-    insert(..._args: Parameters<Table<IUser>['insert']>): never;
+    insert(..._args: Parameters<Table<IUser>["insert"]>): never;
     /** @deprecated Forbidden on UsersTable; use save() */
-    update(..._args: Parameters<Table<IUser>['update']>): never;
+    update(..._args: Parameters<Table<IUser>["update"]>): never;
 }
 export declare function Users(dataContext?: DataContext): UsersTable;
 export declare function getMe(): Promise<IUser>;

package/dist/data/users.js

@@ -48,20 +48,21 @@ const user_permissions_1 = require("./user-permissions");
 exports.userSchema = zod_1.z.object({
     userId: zod_types_1.zodPeerId,
     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'),
-    signature: zod_1.z.string().optional().describe('The signed hash of this user object excluding the signature itself'),
+    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"),
+    signature: zod_1.z
+        .string()
+        .optional()
+        .describe("The signed hash of this user object excluding the signature itself"),
 });
 const metaData = {
-    name: 'Users',
-    description: 'users',
-    primaryKeyName: 'userId',
+    name: "Users",
+    description: "users",
+    primaryKeyName: "userId",
     fields: (0, types_1.schemaToFields)(exports.userSchema),
-    indexes: [
-        { fields: ['name'] },
-        { fields: ['publicKey'] },
-        { fields: ['publicBoxKey'] },
-    ]
+    indexes: [{ fields: ["name"] }, { fields: ["publicKey"] }, { fields: ["publicBoxKey"] }],
 };
 let UsersTable = (() => {
     let _classSuper = table_1.Table;
@@ -94,7 +95,7 @@ let UsersTable = (() => {
         }
         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.');
+                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);
@@ -105,11 +106,11 @@ let UsersTable = (() => {
         }
         /** @deprecated Forbidden on UsersTable; use save() */
         insert(..._args) {
-            throw new Error('UsersTable forbids insert; use save()');
+            throw new Error("UsersTable forbids insert; use save()");
         }
         /** @deprecated Forbidden on UsersTable; use save() */
         update(..._args) {
-            throw new Error('UsersTable forbids update; use save()');
+            throw new Error("UsersTable forbids update; use save()");
         }
         constructor() {
             super(...arguments);
@@ -127,7 +128,7 @@ async function getMe() {
     const userContext = await (0, user_context_singleton_1.getUserContext)();
     const me = await userContext.getMe();
     if (!me) {
-        throw new Error('My user object was not found in the DB. Is the user setup?');
+        throw new Error("My user object was not found in the DB. Is the user setup?");
     }
     return me;
 }

package/dist/data/voice-messages.d.ts

@@ -1,5 +1,5 @@
-import { z } from 'zod';
-import { DataContext } from '../context/data-context';
+import { z } from "zod";
+import type { DataContext } from "../context/data-context";
 export declare const voiceMessageSchema: z.ZodObject<{
     voiceMessageId: z.ZodDefault<z.ZodEffects<z.ZodString, string, string>>;
     sessionId: z.ZodString;

package/dist/data/voice-messages.js

@@ -2,30 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.voiceMessageSchema = void 0;
 exports.VoiceMessages = VoiceMessages;
-const types_1 = require("./orm/types");
-const utils_1 = require("../utils");
 const zod_1 = require("zod");
-const zod_types_1 = require("../types/zod-types");
 const user_context_singleton_1 = require("../context/user-context-singleton");
+const zod_types_1 = require("../types/zod-types");
+const utils_1 = require("../utils");
 const table_definitions_system_1 = require("./orm/table-definitions.system");
+const types_1 = require("./orm/types");
 exports.voiceMessageSchema = zod_1.z.object({
     voiceMessageId: zod_types_1.zodPeerId.default(() => (0, utils_1.newid)()),
-    sessionId: zod_1.z.string().describe('Groups messages belonging to one voice session'),
-    role: zod_1.z.enum(['user', 'assistant']),
+    sessionId: zod_1.z.string().describe("Groups messages belonging to one voice session"),
+    role: zod_1.z.enum(["user", "assistant"]),
     content: zod_1.z.string(),
-    threadId: zod_1.z.string().optional().describe('messageId of the channel thread created when an action was dispatched to the background agent'),
+    threadId: zod_1.z
+        .string()
+        .optional()
+        .describe("messageId of the channel thread created when an action was dispatched to the background agent"),
     createdAt: zod_1.z.date().default(() => new Date()),
 });
 const metaData = {
-    name: 'VoiceMessages',
-    description: 'Voice conversation history for the self-contained voice assistant',
-    primaryKeyName: 'voiceMessageId',
+    name: "VoiceMessages",
+    description: "Voice conversation history for the self-contained voice assistant",
+    primaryKeyName: "voiceMessageId",
     fields: (0, types_1.schemaToFields)(exports.voiceMessageSchema),
     localOnly: true,
-    indexes: [
-        { fields: ['sessionId'] },
-        { fields: ['sessionId', 'createdAt'] },
-    ],
+    indexes: [{ fields: ["sessionId"] }, { fields: ["sessionId", "createdAt"] }],
 };
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.voiceMessageSchema);
 function VoiceMessages(dataContext) {

package/dist/data/welcome-modal.pvar.js

@@ -12,4 +12,6 @@ const persistent_vars_1 = require("./persistent-vars");
  *
  * Defaults to false, meaning new users will see the modal after account creation.
  */
-exports.hasShownWelcomeModal = (0, persistent_vars_1.deviceVar)('hasShownWelcomeModal', { defaultValue: false });
+exports.hasShownWelcomeModal = (0, persistent_vars_1.deviceVar)("hasShownWelcomeModal", {
+    defaultValue: false,
+});

package/dist/data/workflow-logs.js

@@ -3,30 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getLogger = exports.workflowLogSchema = void 0;
 exports.WorkflowLogs = WorkflowLogs;
 const zod_1 = require("zod");
+const user_context_singleton_1 = require("../context/user-context-singleton");
 const workflow_1 = require("../types/workflow");
 const zod_types_1 = require("../types/zod-types");
 const utils_1 = require("../utils");
-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 types_1 = require("./orm/types");
 exports.workflowLogSchema = zod_1.z.object({
     workflowLogId: zod_types_1.zodPeerId,
-    workflowRunId: zod_types_1.zodPeerId.describe('The workflow run that this log entry is associated with'),
-    contextId: zod_types_1.zodPeerId.describe('The context that this log entry is associated with'),
-    logDT: zod_1.z.date().default(() => new Date()).describe('The date the log occurred'),
-    logText: zod_1.z.string().describe('The text of the log entry'),
-    result: zod_1.z.string().optional().describe('The result of the instructions'),
-    instruction: workflow_1.workflowInstructionSchema.optional().describe('The instruction that was run'),
-    toolId: zod_types_1.zodPeerId.optional().describe('The tool that was run'),
-    toolArgs: zod_types_1.zodAnyObject.optional().describe('The arguments that were passed to the tool'),
-    toolRunTimeMs: zod_1.z.number().optional().describe('The time it took to run the tool in milliseconds'),
-    resultObject: zod_types_1.zodAnyObjectOrArray.optional().describe('If the result is structured data it will be stored here'),
-    isError: zod_1.z.boolean().optional().describe('Whether or not the log entry is the result of an error'),
+    workflowRunId: zod_types_1.zodPeerId.describe("The workflow run that this log entry is associated with"),
+    contextId: zod_types_1.zodPeerId.describe("The context that this log entry is associated with"),
+    logDT: zod_1.z
+        .date()
+        .default(() => new Date())
+        .describe("The date the log occurred"),
+    logText: zod_1.z.string().describe("The text of the log entry"),
+    result: zod_1.z.string().optional().describe("The result of the instructions"),
+    instruction: workflow_1.workflowInstructionSchema.optional().describe("The instruction that was run"),
+    toolId: zod_types_1.zodPeerId.optional().describe("The tool that was run"),
+    toolArgs: zod_types_1.zodAnyObject.optional().describe("The arguments that were passed to the tool"),
+    toolRunTimeMs: zod_1.z.number().optional().describe("The time it took to run the tool in milliseconds"),
+    resultObject: zod_types_1.zodAnyObjectOrArray
+        .optional()
+        .describe("If the result is structured data it will be stored here"),
+    isError: zod_1.z
+        .boolean()
+        .optional()
+        .describe("Whether or not the log entry is the result of an error"),
 });
 const metaData = {
-    name: 'WorkflowLogs',
-    description: 'The log entries for workflow runs.',
-    primaryKeyName: 'workflowLogId',
+    name: "WorkflowLogs",
+    description: "The log entries for workflow runs.",
+    primaryKeyName: "workflowLogId",
     fields: (0, types_1.schemaToFields)(exports.workflowLogSchema),
 };
 (0, table_definitions_system_1.registerSystemTableDefinition)(metaData, exports.workflowLogSchema);
@@ -37,7 +45,7 @@ const getLogger = (workflowRunId, contextId) => {
     return async (logData) => {
         try {
             let logRecord;
-            if (typeof logData === 'string') {
+            if (typeof logData === "string") {
                 logRecord = WorkflowLogs().initRecord({
                     workflowRunId,
                     workflowLogId: (0, utils_1.newid)(),
@@ -52,7 +60,7 @@ const getLogger = (workflowRunId, contextId) => {
                 });
             }
             logRecord.workflowRunId = workflowRunId;
-            logRecord.logText = logRecord.logText || '';
+            logRecord.logText = logRecord.logText || "";
             logRecord.contextId = contextId;
             return await WorkflowLogs().insert(logRecord);
         }