@peers-app/peers-sdk 0.14.0 → 0.15.0

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { ITableMetaData } from "../data/orm/types";
-import { ITableDependencies, Table } from "../data/orm";
+import { type ITableDependencies, Table } from "../data/orm";
+import { type ITableMetaData } from "../data/orm/types";
 export declare const consoleLogSchema: z.ZodObject<{
     logId: z.ZodEffects<z.ZodString, string, string>;
     timestamp: z.ZodDefault<z.ZodNumber>;
@@ -13,9 +13,9 @@ export declare const consoleLogSchema: z.ZodObject<{
     stackTrace: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     message: string;
+    timestamp: number;
     level: "error" | "debug" | "info" | "log" | "warn";
     logId: string;
-    timestamp: number;
     process: string;
     processInstanceId: string;
     source?: string | undefined;

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

@@ -37,34 +37,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleLogsTable = exports.consoleLogSchema = void 0;
 exports.ConsoleLogs = ConsoleLogs;
 const zod_1 = require("zod");
-const zod_types_1 = require("../types/zod-types");
-const types_1 = require("../data/orm/types");
 const user_context_singleton_1 = require("../context/user-context-singleton");
+const orm_1 = require("../data/orm");
 const table_definitions_system_1 = require("../data/orm/table-definitions.system");
+const types_1 = require("../data/orm/types");
+const zod_types_1 = require("../types/zod-types");
 const utils_1 = require("../utils");
-const orm_1 = require("../data/orm");
 exports.consoleLogSchema = zod_1.z.object({
     logId: zod_types_1.zodPeerId,
-    timestamp: zod_1.z.number().default(() => (0, utils_1.getTimestamp)()).describe('The timestamp the log was created created'),
-    level: zod_1.z.enum(['debug', 'info', 'log', 'warn', 'error']).describe('The log level'),
-    process: zod_1.z.string().describe('The process that generated the log (e.g., main, renderer, worker)'),
-    processInstanceId: zod_1.z.string().describe('Unique ID for this process instance to filter own logs'),
-    source: zod_1.z.string().optional().describe('The source file or module that generated the log'),
-    message: zod_1.z.string().describe('The log message'),
-    context: zod_types_1.zodAnyObjectOrArray.optional().describe('Additional structured context data'),
-    stackTrace: zod_1.z.string().optional().describe('Stack trace for errors'),
+    timestamp: zod_1.z
+        .number()
+        .default(() => (0, utils_1.getTimestamp)())
+        .describe("The timestamp the log was created created"),
+    level: zod_1.z.enum(["debug", "info", "log", "warn", "error"]).describe("The log level"),
+    process: zod_1.z.string().describe("The process that generated the log (e.g., main, renderer, worker)"),
+    processInstanceId: zod_1.z.string().describe("Unique ID for this process instance to filter own logs"),
+    source: zod_1.z.string().optional().describe("The source file or module that generated the log"),
+    message: zod_1.z.string().describe("The log message"),
+    context: zod_types_1.zodAnyObjectOrArray.optional().describe("Additional structured context data"),
+    stackTrace: zod_1.z.string().optional().describe("Stack trace for errors"),
 });
 const metaData = {
-    name: 'ConsoleLogs',
-    description: 'System-wide console log entries with cross-process visibility.',
-    primaryKeyName: 'logId',
+    name: "ConsoleLogs",
+    description: "System-wide console log entries with cross-process visibility.",
+    primaryKeyName: "logId",
     fields: (0, types_1.schemaToFields)(exports.consoleLogSchema),
     localOnly: true, // Don't sync logs between devices
     indexes: [
-        { fields: ['timestamp'] },
-        { fields: ['level'] },
-        { fields: ['process'] },
-        { fields: ['processInstanceId'] },
+        { fields: ["timestamp"] },
+        { fields: ["level"] },
+        { fields: ["process"] },
+        { fields: ["processInstanceId"] },
     ],
 };
 let ConsoleLogsTable = (() => {
@@ -85,7 +88,7 @@ let ConsoleLogsTable = (() => {
         LOG_CLEANUP_INTERVAL = 24 * 60 * 60 * 1000; // 1 day
         constructor(metaData, deps) {
             super(metaData, deps);
-            if (typeof process !== 'undefined' && process.env.NODE_ENV !== 'test') {
+            if (typeof process !== "undefined" && process.env.NODE_ENV !== "test") {
                 this.initializeLogCleanup();
             }
         }
@@ -97,7 +100,7 @@ let ConsoleLogsTable = (() => {
             this.logCleanupInitialized = true;
             // always cleanup old logs on startup - randomly spread out of the first 60 seconds to not slam the db
             setTimeout(() => this.deleteOldLogs(), 60_000 * Math.random());
-            // regularly clean up logs 
+            // regularly clean up logs
             // TODO - consider doing this as a workflow
             setInterval(() => this.deleteOldLogs(), this.LOG_CLEANUP_INTERVAL);
         }
@@ -113,12 +116,14 @@ let ConsoleLogsTable = (() => {
             }
             if (ds instanceof orm_1.SQLDataSource) {
                 const db = ds.db;
-                const result = await db.exec(`delete from ConsoleLogs where timestamp < $timestamp`, { timestamp: cutoffTimestamp });
+                const result = await db.exec(`delete from ConsoleLogs where timestamp < $timestamp`, {
+                    timestamp: cutoffTimestamp,
+                });
                 console.log(`bulk deleted ${count} logs, changes: ${result.changes}`);
             }
             else {
-                const cursor = this.cursor({ timestamp: { $lt: cutoffTimestamp } }, { sortBy: ['-timestamp'] });
-                let count2 = 0;
+                const cursor = this.cursor({ timestamp: { $lt: cutoffTimestamp } }, { sortBy: ["-timestamp"] });
+                const count2 = 0;
                 for await (const log of cursor) {
                     this.delete(log.logId);
                 }

package/dist/mentions.js

@@ -6,32 +6,36 @@ exports.getAllMentions = exports.formatMention = exports.mentionRegex = void 0;
 const mentionRegex = () => /<(@|\$)([a-zA-Z0-9_-]+):([a-zA-Z0-9_-]+):([a-zA-Z0-9]{25})?>/;
 exports.mentionRegex = mentionRegex;
 const formatMention = (data) => {
-    let prefix = '$';
-    if (data.kind === 'assistant' || data.kind === 'user') {
-        prefix = '@';
+    let prefix = "$";
+    if (data.kind === "assistant" || data.kind === "user") {
+        prefix = "@";
     }
-    let name = data.name.replace(/\s/g, '_');
+    let name = data.name.replace(/\s/g, "_");
     // remove non-alphanumeric characters
-    name = name.replace(/[^a-zA-Z0-9_-]/g, '');
+    name = name.replace(/[^a-zA-Z0-9_-]/g, "");
     let mention = `<${prefix}${data.kind}:${name}:${data.id}`;
     // if (data.kind === 'assistant') {
     //   mention += `:${data.userId}`;
     // }
-    mention += '>';
+    mention += ">";
     return mention;
 };
 exports.formatMention = formatMention;
 const getAllMentions = (markdown) => {
     const mentions = [];
-    let lastIndex = 0;
+    let _lastIndex = 0;
     let match;
-    let cnt = 0;
+    let _cnt = 0;
     const regex = (0, exports.mentionRegex)();
-    while ((match = regex.exec(markdown)) !== null) {
-        cnt++;
+    while (true) {
+        match = regex.exec(markdown);
+        if (match === null) {
+            break;
+        }
+        _cnt++;
         markdown = markdown.slice(match.index + match[0].length);
         const kind = match[2];
-        const name = match[3].replace(/_/g, ' ');
+        const name = match[3].replace(/_/g, " ");
         const id = match[4];
         const data = {
             kind: kind,
@@ -39,7 +43,7 @@ const getAllMentions = (markdown) => {
             id,
         };
         mentions.push(data);
-        lastIndex = regex.lastIndex;
+        _lastIndex = regex.lastIndex;
     }
     return mentions;
 };

package/dist/observable.d.ts

@@ -13,10 +13,10 @@ type ObservableProps<T> = {
 export type Observable<T> = ObservableFn<T> & ObservableProps<T>;
 export declare function observable<T>(initialValue: T): Observable<T>;
 export declare function observable<T = undefined>(): Observable<T | undefined>;
-export declare function computed<T>(fn: ({
+export declare function computed<T>(fn: {
     read: () => T;
     write?: (val: T) => void;
-}) | (() => T)): Observable<T>;
+} | (() => T)): Observable<T>;
 export declare function isSubscribable(obj: any): obj is Observable<any>;
 export declare function unwrapObservable<T>(obj: T | Observable<T>): T;
 export declare function linkObservables<T>(obs1: Observable<T>, obs2: Observable<T>): Subscription;

package/dist/observable.js

@@ -13,7 +13,9 @@ function observable(initialValue) {
     let value = initialValue;
     const subscribers = [];
     const obs = ((...args) => {
-        Object.values(runningComputes).forEach(c => c.push(obs));
+        Object.values(runningComputes).forEach((c) => {
+            c.push(obs);
+        });
         const isSetting = args.length > 0;
         const newValue = args[0];
         if (isSetting && newValue !== value) {
@@ -23,7 +25,9 @@ function observable(initialValue) {
         return value;
     });
     obs.notifySubscribers = () => {
-        subscribers.forEach(subscriber => subscriber(value));
+        subscribers.forEach((subscriber) => {
+            subscriber(value);
+        });
     };
     obs.subscribe = (subscriber) => {
         subscribers.push(subscriber);
@@ -36,7 +40,7 @@ function observable(initialValue) {
                 if (iSub >= 0) {
                     subscribers.splice(iSub, 1);
                 }
-            }
+            },
         };
     };
     obs.subscriberCount = () => subscribers.length;
@@ -63,7 +67,7 @@ function computed(fn) {
                 return recompute();
             }
             else {
-                throw new Error('Computed value is readonly');
+                throw new Error("Computed value is readonly");
             }
         }
         if (dirty) {
@@ -80,23 +84,25 @@ function computed(fn) {
         }
     };
     // subscribe to dependencies
-    (0, lodash_1.uniq)(dependencies).forEach(dep => dep.subscribe(onDepChange));
+    (0, lodash_1.uniq)(dependencies).forEach((dep) => {
+        dep.subscribe(onDepChange);
+    });
     Object.assign(obs, _obs);
     return obs;
 }
 function isSubscribable(obj) {
-    return obj && typeof obj === 'function' && obj.subscribe && obj.notifySubscribers;
+    return obj && typeof obj === "function" && obj.subscribe && obj.notifySubscribers;
 }
 function unwrapObservable(obj) {
     return isSubscribable(obj) ? obj() : obj;
 }
 function linkObservables(obs1, obs2) {
-    const sub1 = obs1.subscribe(value => {
+    const sub1 = obs1.subscribe((value) => {
         if (value !== obs2()) {
             obs2(value);
         }
     });
-    const sub2 = obs2.subscribe(value => {
+    const sub2 = obs2.subscribe((value) => {
         if (value !== obs1()) {
             obs1(value);
         }
@@ -105,6 +111,6 @@ function linkObservables(obs1, obs2) {
         dispose: () => {
             sub1.dispose();
             sub2.dispose();
-        }
+        },
     };
 }

package/dist/observable.test.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const observable_1 = require("./observable");
-describe('observable.ts', () => {
-    describe('observable', () => {
-        it('should be able to create an observable', () => {
+describe("observable.ts", () => {
+    describe("observable", () => {
+        it("should be able to create an observable", () => {
             const obs = (0, observable_1.observable)(3);
             expect(obs()).toBe(3);
         });
-        it('should be able to update an observable', () => {
+        it("should be able to update an observable", () => {
             const obs = (0, observable_1.observable)(3);
             obs(4);
             expect(obs()).toBe(4);
         });
-        it('should be able to subscribe to an observable', () => {
+        it("should be able to subscribe to an observable", () => {
             const obs = (0, observable_1.observable)(3);
             let value = 0;
-            const sub = obs.subscribe(newValue => {
+            const sub = obs.subscribe((newValue) => {
                 value = newValue;
             });
             expect(value).toBe(0);
@@ -25,30 +25,30 @@ describe('observable.ts', () => {
             obs(5);
             expect(value).toBe(4);
         });
-        it('should return the value when writing to itself', () => {
+        it("should return the value when writing to itself", () => {
             const obs = (0, observable_1.observable)(3);
             expect(obs(4)).toBe(4);
         });
-        it('should be able to set an observable to undefined', () => {
+        it("should be able to set an observable to undefined", () => {
             const obs = (0, observable_1.observable)(3);
             obs(undefined);
             expect(obs()).toBe(undefined);
         });
-        it('should notify subscribers when value is set to undefined', () => {
+        it("should notify subscribers when value is set to undefined", () => {
             const obs = (0, observable_1.observable)(3);
             let value = 99;
-            const sub = obs.subscribe(newValue => {
+            const sub = obs.subscribe((newValue) => {
                 value = newValue;
             });
             obs(undefined);
             expect(value).toBe(undefined);
             sub.dispose();
         });
-        it('should be able to initialize an observable with undefined', () => {
+        it("should be able to initialize an observable with undefined", () => {
             const obs = (0, observable_1.observable)(undefined);
             expect(obs()).toBe(undefined);
         });
-        it('should distinguish between getting (no args) and setting to undefined (with arg)', () => {
+        it("should distinguish between getting (no args) and setting to undefined (with arg)", () => {
             const obs = (0, observable_1.observable)(5);
             // Getting with no args
             expect(obs()).toBe(5);
@@ -56,7 +56,7 @@ describe('observable.ts', () => {
             obs(undefined);
             expect(obs()).toBe(undefined);
         });
-        it('should not notify subscribers when value does not change', () => {
+        it("should not notify subscribers when value does not change", () => {
             const obs = (0, observable_1.observable)(3);
             let notifyCount = 0;
             obs.subscribe(() => {
@@ -67,8 +67,8 @@ describe('observable.ts', () => {
             obs(4);
             expect(notifyCount).toBe(1);
         });
-        it('should handle setting undefined multiple times', () => {
-            const obs = (0, observable_1.observable)('test');
+        it("should handle setting undefined multiple times", () => {
+            const obs = (0, observable_1.observable)("test");
             let notifyCount = 0;
             obs.subscribe(() => {
                 notifyCount++;
@@ -78,12 +78,12 @@ describe('observable.ts', () => {
             obs(undefined);
             // Should not notify since value hasn't changed
             expect(notifyCount).toBe(1);
-            obs('new');
+            obs("new");
             expect(notifyCount).toBe(2);
             obs(undefined);
             expect(notifyCount).toBe(3);
         });
-        it('should correctly detect args.length for get vs set', () => {
+        it("should correctly detect args.length for get vs set", () => {
             const obs = (0, observable_1.observable)(10);
             const calls = [];
             // Wrap the observable to track calls
@@ -103,76 +103,76 @@ describe('observable.ts', () => {
             wrappedObs();
             expect(calls[2]).toEqual({ argsLength: 0, value: undefined });
         });
-        it('should allow creating observable without initial value for types that include undefined', () => {
+        it("should allow creating observable without initial value for types that include undefined", () => {
             const obs = (0, observable_1.observable)();
             expect(obs()).toBe(undefined);
-            obs('test');
-            expect(obs()).toBe('test');
+            obs("test");
+            expect(obs()).toBe("test");
             obs(undefined);
             expect(obs()).toBe(undefined);
         });
-        it('should work with explicit type and initial value', () => {
+        it("should work with explicit type and initial value", () => {
             const obs = (0, observable_1.observable)(42);
             expect(obs()).toBe(42);
             obs(100);
             expect(obs()).toBe(100);
         });
-        it('should not allow creating observable without initial value for types that cannot be undefined', () => {
+        it("should not allow creating observable without initial value for types that cannot be undefined", () => {
             const obs = (0, observable_1.observable)();
             // @ts-expect-error
             const s = obs();
             expect(s).toBeUndefined();
-            obs('s');
-            expect(obs()).toEqual('s');
+            obs("s");
+            expect(obs()).toEqual("s");
             obs(undefined);
             expect(obs()).toEqual(undefined);
-            const obs2 = (0, observable_1.observable)('');
+            const obs2 = (0, observable_1.observable)("");
             const s2 = obs2();
-            expect(s2).toEqual('');
+            expect(s2).toEqual("");
             // @ts-expect-error
             obs2(undefined);
             expect(obs2()).toBeUndefined();
         });
-        it('should infer type from initial value', () => {
+        it("should infer type from initial value", () => {
             // Infer number from numeric literal
             const numObs = (0, observable_1.observable)(42);
             const num = numObs();
             expect(num).toBe(42);
             // Infer string from string literal
-            const strObs = (0, observable_1.observable)('hello');
+            const strObs = (0, observable_1.observable)("hello");
             const str = strObs();
-            expect(str).toBe('hello');
+            expect(str).toBe("hello");
             // Infer boolean from boolean literal
             const boolObs = (0, observable_1.observable)(true);
             const bool = boolObs();
             expect(bool).toBe(true);
             // Infer object type
-            const objObs = (0, observable_1.observable)({ name: 'test', count: 5 });
+            const objObs = (0, observable_1.observable)({ name: "test", count: 5 });
             const obj = objObs();
-            expect(obj).toEqual({ name: 'test', count: 5 });
+            expect(obj).toEqual({ name: "test", count: 5 });
             // Infer array type
             const arrObs = (0, observable_1.observable)([1, 2, 3]);
             const arr = arrObs();
             expect(arr).toEqual([1, 2, 3]);
         });
     });
-    describe('computed', () => {
-        it('should be able to create a computed observable', () => {
+    describe("computed", () => {
+        it("should be able to create a computed observable", () => {
             const com = (0, observable_1.computed)(() => 3);
             expect(com()).toBe(3);
         });
-        it('should throw if trying to set value', () => {
+        it("should throw if trying to set value", () => {
             const com = (0, observable_1.computed)(() => 3);
             expect(() => com(4)).toThrow();
         });
-        it('should be able to create a computed observable that depends on another observable', () => {
+        it("should be able to create a computed observable that depends on another observable", () => {
             const obs1 = (0, observable_1.observable)(3);
             const com1 = (0, observable_1.computed)(() => obs1() + 1);
             expect(com1()).toBe(4);
             obs1(5);
             expect(com1()).toBe(6);
         });
-        it('should be able to create a computed observable that depends on another computed observable', () => {
+        it("should be able to create a computed observable that depends on another computed observable", () => {
             const obs1 = (0, observable_1.observable)(3);
             const com1 = (0, observable_1.computed)(() => obs1() + 1);
             const com2 = (0, observable_1.computed)(() => com1() + 1);
@@ -180,18 +180,18 @@ describe('observable.ts', () => {
             obs1(5);
             expect(com2()).toBe(7);
         });
-        it('should be able to create a computed observable that depends on another computed observable that depends on another computed observable', () => {
+        it("should be able to create a computed observable that depends on another computed observable that depends on another computed observable", () => {
             const obs1 = (0, observable_1.observable)(3);
             const com1 = (0, observable_1.computed)(() => obs1() + 1);
             const com2 = (0, observable_1.computed)(() => com1() + 1);
             const com3 = (0, observable_1.computed)(() => com2() + 1);
             expect(com3()).toBe(6);
         });
-        it('should notify subscribers of new value when a dependency changes', () => {
+        it("should notify subscribers of new value when a dependency changes", () => {
             const obs1 = (0, observable_1.observable)(3);
             const com1 = (0, observable_1.computed)(() => obs1() + 1);
             let newValue = 0;
-            com1.subscribe(val => {
+            com1.subscribe((val) => {
                 newValue = val;
             });
             expect(com1()).toBe(4);
@@ -199,7 +199,7 @@ describe('observable.ts', () => {
             obs1(5);
             expect(newValue).toBe(6);
         });
-        it('should not notify subscribers of new value when a dependency changes if there are no subscribers', () => {
+        it("should not notify subscribers of new value when a dependency changes if there are no subscribers", () => {
             const obs1 = (0, observable_1.observable)(1);
             let computeCount = 0;
             const com1 = (0, observable_1.computed)(() => {
@@ -207,7 +207,7 @@ describe('observable.ts', () => {
                 return obs1() + 1;
             });
             let newValue = 0;
-            const sub = com1.subscribe(val => {
+            const sub = com1.subscribe((val) => {
                 newValue = val;
             });
             expect(computeCount).toBe(1);
@@ -225,7 +225,7 @@ describe('observable.ts', () => {
             expect(computeCount).toBe(3);
             expect(com1()).toBe(4);
         });
-        it('should only recompute value when a dependency changes if there are subscribers', () => {
+        it("should only recompute value when a dependency changes if there are subscribers", () => {
             const obs1 = (0, observable_1.observable)(1);
             let recomputeCount = 0;
             const com1 = (0, observable_1.computed)(() => {
@@ -245,7 +245,7 @@ describe('observable.ts', () => {
             expect(com1()).toBe(4);
             expect(recomputeCount).toBe(2);
         });
-        it('should immediately, and still only, recompute value when a dependency changes if there are subscribers', () => {
+        it("should immediately, and still only, recompute value when a dependency changes if there are subscribers", () => {
             const obs1 = (0, observable_1.observable)(1);
             let recomputeCount = 0;
             const com1 = (0, observable_1.computed)(() => {
@@ -253,7 +253,7 @@ describe('observable.ts', () => {
                 return obs1() + recomputeCount;
             });
             let newValue = 0;
-            com1.subscribe(val => {
+            com1.subscribe((val) => {
                 newValue = val;
             });
             expect(com1()).toBe(2);
@@ -266,7 +266,7 @@ describe('observable.ts', () => {
             expect(com1()).toBe(4);
             expect(com1()).toBe(4);
         });
-        it('notify should set the value and notify subscribers without recomputing', () => {
+        it("notify should set the value and notify subscribers without recomputing", () => {
             const obs1 = (0, observable_1.observable)(1);
             let recomputeCount = 0;
             const com1 = (0, observable_1.computed)(() => {
@@ -274,7 +274,7 @@ describe('observable.ts', () => {
                 return obs1() + recomputeCount;
             });
             let newValue = 0;
-            com1.subscribe(val => {
+            com1.subscribe((val) => {
                 newValue = val;
             });
             expect(com1()).toBe(2);
@@ -291,7 +291,7 @@ describe('observable.ts', () => {
             // expect(com1()).toBe(5);
             // expect(recomputeCount).toBe(2);
         });
-        it('should allow configuring a write function', () => {
+        it("should allow configuring a write function", () => {
             const obs1 = (0, observable_1.observable)(1);
             const com1 = (0, observable_1.computed)({
                 read: () => obs1() + 1,

package/dist/package-loader/get-require.js

@@ -17,12 +17,11 @@ async function getRequire(injected) {
     }
     // Try ESM fallback: createRequire(import.meta.url)
     try {
-        const mod = await Promise.resolve().then(() => require("module"));
+        const mod = (await Promise.resolve().then(() => require("node:module")));
         // Use import.meta.url if TS target supports it, else __filename
         const urlOrPath = 
-        // @ts-ignore
-        typeof import.meta !== "undefined" && import.meta.url ? import.meta.url
-            : __filename;
+        // @ts-expect-error
+        typeof import.meta !== "undefined" && import.meta.url ? import.meta.url : __filename;
         return mod.createRequire(urlOrPath);
     }
     catch {

package/dist/package-loader/package-loader.d.ts

@@ -1,6 +1,6 @@
 import type { DataContext } from "../context/data-context";
+import { type IPackage } from "../data/packages";
 import type { IPeersPackage } from "../types/peers-package";
-import { IPackage } from "../data/packages";
 export declare class PackageLoader {
     readonly dataContext: DataContext;
     static PeersSDK: any;
@@ -18,4 +18,4 @@ export declare class PackageLoader {
     private _readLocalBundle;
     private _evaluateBundle;
 }
-export declare function setDefaultRequire(require: (<T>(module: string) => T)): void;
+export declare function setDefaultRequire(require: <T>(module: string) => T): void;