sliftutils 1.1.4 → 1.1.40

package/misc/https/httpsCerts.d.ts

@@ -1,3 +1,8 @@
+/// <reference path="node-forge-ed25519.d.ts" />
+/// <reference path="../../storage/storage.d.ts" />
+/// <reference types="node" />
+/// <reference types="node" />
+import * as forge from "node-forge";
 /** NOTE: We also generate the domain *.domain */
 export declare const getHTTPSCert: {
     (key: string): Promise<{
@@ -16,3 +21,15 @@ export declare const getHTTPSCert: {
         cert: string;
     }> | undefined;
 };
+export declare const getAccountKey: (domain: string) => Promise<string>;
+export declare function parseCert(PEMorDER: string | Buffer): forge.pki.Certificate;
+export declare function normalizeCertToPEM(PEMorDER: string | Buffer): string;
+export declare function generateCert(config: {
+    accountKey: string;
+    domain: string;
+    altDomains?: string[];
+}): Promise<{
+    domains: string[];
+    key: string;
+    cert: string;
+}>;

package/misc/https/httpsCerts.ts

@@ -91,7 +91,7 @@ export const getHTTPSCert = cache(async (domain: string): Promise<{ key: string;
 });
 
 
-const getAccountKey = async function getAccountKey(domain: string) {
+export const getAccountKey = async function getAccountKey(domain: string) {
     let accountKey = getKeyStore<string>(domain, "letsEncryptAccountKey");
     let secret = await accountKey.get();
     if (!secret) {
@@ -105,11 +105,11 @@ const getAccountKey = async function getAccountKey(domain: string) {
 };
 
 
-function parseCert(PEMorDER: string | Buffer) {
+export function parseCert(PEMorDER: string | Buffer) {
     return forge.pki.certificateFromPem(normalizeCertToPEM(PEMorDER));
 }
 
-function normalizeCertToPEM(PEMorDER: string | Buffer): string {
+export function normalizeCertToPEM(PEMorDER: string | Buffer): string {
     if (PEMorDER.toString().startsWith("-----BEGIN CERTIFICATE-----")) {
         return PEMorDER.toString();
     }
@@ -118,7 +118,7 @@ function normalizeCertToPEM(PEMorDER: string | Buffer): string {
 }
 
 
-async function generateCert(config: {
+export async function generateCert(config: {
     accountKey: string;
     domain: string;
     altDomains?: string[];

package/misc/openrouter.d.ts

@@ -13,6 +13,7 @@ export type MessageHistory2 = {
 }[];
 export declare function getTotalCost(): number;
 type OpenRouterOptions = {
+    apiKey?: string;
     provider?: {
         sort?: "throughput" | "price" | "latency";
         order?: string[];

package/misc/openrouter.ts

@@ -1,5 +1,7 @@
 import { parseYAML } from "./yaml";
 import { retryFunctional } from "socket-function/src/batching";
+
+const CANNOT_RETRY = "(CANNOT RETRY)";
 import { formatNumber } from "socket-function/src/formatting/format";
 import { getAPIKey } from "./apiKeys";
 
@@ -22,6 +24,8 @@ export function getTotalCost() {
     return totalCost;
 }
 type OpenRouterOptions = {
+    // If not provided, we'll pop up a modal to ask the user for it, Or, if we're on the server, we'll try to read it from the user folder.
+    apiKey?: string;
     provider?: {
         sort?: "throughput" | "price" | "latency",
         // https://openrouter.ai/docs/features/provider-routing#ordering-specific-providers
@@ -90,12 +94,11 @@ export async function openRouterCallBase(config: {
     retries?: number;
 }): Promise<string> {
     let { model, messages, options, onCost } = config;
-    let openrouterKey = await getAPIKey("openrouter.json");
+    let openrouterKey = options?.apiKey || await getAPIKey("openrouter.json");
     console.log(`Calling ${model} with ${messages.length} messages`);
     let time = Date.now();
     let stillRunning = true;
 
-    // Spawn monitoring loop
     void (async () => {
         while (stillRunning) {
             await new Promise(resolve => setTimeout(resolve, 5000));
@@ -124,7 +127,6 @@ export async function openRouterCallBase(config: {
                 }),
             });
 
-            // If it failed, throw
             if (response.status !== 200) {
                 let responseText = await response.text();
                 throw new Error(`Failed to call OpenRouter: ${response.status} ${response.statusText} ${responseText}`);
@@ -134,11 +136,34 @@ export async function openRouterCallBase(config: {
                     cost: number;
                 };
                 choices: {
+                    finish_reason?: string;
                     message: {
                         content: string;
+                        refusal?: string | null;
                     };
                 }[];
+                error?: {
+                    code?: number | string;
+                    message?: string;
+                    metadata?: unknown;
+                };
             };
+            if (responseObj.error) {
+                throw new Error(`OpenRouter returned an error: ${responseObj.error.code} ${responseObj.error.message} ${JSON.stringify(responseObj.error.metadata)}`);
+            }
+            let choice = responseObj.choices?.[0];
+            if (!choice) {
+                throw new Error(`OpenRouter returned no choices: ${JSON.stringify(responseObj)}`);
+            }
+            if (choice.message.refusal) {
+                throw new Error(`OpenRouter model refused content: ${choice.message.refusal} ${CANNOT_RETRY}`);
+            }
+            if (choice.finish_reason === "content_filter") {
+                throw new Error(`OpenRouter content filter triggered (finish_reason=content_filter): ${choice.message.content ?? ""} ${CANNOT_RETRY}`);
+            }
+            if (choice.finish_reason === "error") {
+                throw new Error(`OpenRouter completion errored (finish_reason=error): ${choice.message.content ?? ""}`);
+            }
             let newCost = responseObj.usage.cost;
             totalCost += newCost;
             onCost?.(newCost);
@@ -159,7 +184,10 @@ export async function openRouterCallBase(config: {
             pendingLog.duration += Date.now() - time;
             pendingLog.cost += newCost;
             return responseObj.choices[0].message.content as string;
-        }, { maxRetries: config.retries || 3 })();
+        }, {
+            maxRetries: config.retries || 3,
+            shouldRetry: message => !message.includes(CANNOT_RETRY),
+        })();
     } finally {
         stillRunning = false;
     }

package/misc/zip.d.ts

@@ -1,12 +1,2 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { MaybePromise } from "socket-function/src/types";
-export declare class Zip {
-    static gzip(buffer: Buffer, level?: number): Promise<Buffer>;
-    static gunzip(buffer: Buffer): MaybePromise<Buffer>;
-    static gunzipAsyncBase(buffer: Buffer): Promise<Buffer>;
-    static gunzipUntracked(buffer: Buffer): Promise<Buffer>;
-    static gunzipSync(buffer: Buffer): Buffer;
-    private static gunzipUntrackedSync;
-    static gunzipBatch(buffers: Buffer[]): Promise<Buffer[]>;
-}
+import { Zip } from "socket-function/src/Zip";
+export { Zip };

package/misc/zip.ts

@@ -5,102 +5,7 @@ import * as pako from "pako";
 
 import { setFlag } from "socket-function/require/compileFlags";
 import { MaybePromise } from "socket-function/src/types";
+import { Zip } from "socket-function/src/Zip";
 setFlag(require, "pako", "allowclient", true);
 
-const SYNC_THRESHOLD_BYTES = 100_000_000;
-
-export class Zip {
-    @measureFnc
-    public static async gzip(buffer: Buffer, level?: number): Promise<Buffer> {
-        if (isNode()) {
-            return new Promise((resolve, reject) => {
-                zlib.gzip(buffer, { level }, (err: any, result: Buffer) => {
-                    if (err) reject(err);
-                    else resolve(result);
-                });
-            });
-        } else {
-            // @ts-ignore
-            return await doStream(new CompressionStream("gzip"), buffer);
-        }
-    }
-    public static gunzip(buffer: Buffer): MaybePromise<Buffer> {
-        // Switch to the synchronous version if the buffer is small. This is a lot faster in Node.js and clientside.
-        //  - On tests of random small amounts of data, this seems to be up to 7X faster (on node). However, on non-random data, on the actual data we're using, it seems to be almost 50 times faster. So... definitely worth it...
-        if (buffer.length < SYNC_THRESHOLD_BYTES) {
-            let time = Date.now();
-            let result = Zip.gunzipSync(buffer);
-            let duration = Date.now() - time;
-            if (duration > 50) {
-                // Wait, so we don't lock up the main thread. And if we already wait it 50ms, then waiting for one frame is marginal, even client-side. 
-                return ((async () => {
-                    await new Promise(resolve => setTimeout(resolve, 0));
-                    return result;
-                }))();
-            }
-            return result;
-        }
-        return Zip.gunzipAsyncBase(buffer);
-    }
-    @measureFnc
-    public static async gunzipAsyncBase(buffer: Buffer): Promise<Buffer> {
-        return Zip.gunzipUntracked(buffer);
-    }
-    // A base function, so we can avoid instrumentation for batch calls
-    public static async gunzipUntracked(buffer: Buffer): Promise<Buffer> {
-        if (isNode()) {
-            return await new Promise<Buffer>((resolve, reject) => {
-                zlib.gunzip(buffer, (err: any, result: Buffer) => {
-                    if (err) reject(err);
-                    else resolve(result);
-                });
-            });
-        }
-        return await doStream(new DecompressionStream("gzip"), buffer);
-    }
-
-    @measureFnc
-    public static gunzipSync(buffer: Buffer): Buffer {
-        return this.gunzipUntrackedSync(buffer);
-    }
-    private static gunzipUntrackedSync(buffer: Buffer): Buffer {
-        if (isNode()) {
-            return Buffer.from(zlib.gunzipSync(buffer));
-        }
-        return Buffer.from(pako.inflate(buffer));
-    }
-
-    @measureFnc
-    public static async gunzipBatch(buffers: Buffer[]): Promise<Buffer[]> {
-        let time = Date.now();
-        buffers = await Promise.all(buffers.map(x => {
-            if (x.length < SYNC_THRESHOLD_BYTES) {
-                return this.gunzipUntrackedSync(x);
-            }
-            return this.gunzipUntracked(x);
-        }));
-        time = Date.now() - time;
-        let totalSize = buffers.reduce((acc, buffer) => acc + buffer.length, 0);
-        //console.log(`Gunzip ${formatNumber(totalSize)}B at ${formatNumber(totalSize / time * 1000)}B/s`);
-        return buffers;
-    }
-}
-
-async function doStream(stream: GenericTransformStream, buffer: Buffer): Promise<Buffer> {
-    let reader = stream.readable.getReader();
-    let writer = stream.writable.getWriter();
-    let writePromise = writer.write(buffer);
-    let closePromise = writer.close();
-
-    let outputBuffers: Buffer[] = [];
-    while (true) {
-        let { value, done } = await reader.read();
-        if (done) {
-            await writePromise;
-            await closePromise;
-            return Buffer.concat(outputBuffers);
-        }
-        outputBuffers.push(Buffer.from(value));
-    }
-
-}
+export { Zip };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.1.4",
+    "version": "1.1.40",
     "main": "index.js",
     "license": "MIT",
     "files": [
@@ -25,7 +25,8 @@
         "watch-web": "node ./builders/watchRun.js --port 9877 \"web/*.ts\" \"web/*.tsx\" \"yarn build-web\"",
         "watch-extension": "node ./builders/watchRun.js --port 9878 \"extension/*.ts\" \"extension/*.tsx\" \"yarn build-extension\"",
         "watch-electron": "node ./builders/watchRun.js --port 9879 \"electron/*.ts\" \"electron/*.tsx\" \"yarn build-electron\"",
-        "notes": "mobx, preact, socket-function, typenode SHOULD be peerDependencies. But we want to use yarn (better dependency deduplication), so we can't use peerDependencies (as they aren't installed by default, which makes them a nightmare to use). If you want to override the versions, feel free to use overrides/resolutions."
+        "notes": "mobx, preact, socket-function, typenode SHOULD be peerDependencies. But we want to use yarn (better dependency deduplication), so we can't use peerDependencies (as they aren't installed by default, which makes them a nightmare to use). If you want to override the versions, feel free to use overrides/resolutions.",
+        "test": "typenode ./test.ts"
     },
     "bin": {
         "build-nodejs": "./builders/nodeJSBuildRun.js",
@@ -50,7 +51,7 @@
         "mobx": "^6.13.3",
         "preact-old-types": "^10.28.1",
         "shell-quote": "^1.8.3",
-        "socket-function": "^1.0.1",
+        "socket-function": "^1.1.30",
         "typenode": "*",
         "typesafecss": "*",
         "ws": "^8.18.3",

package/render-utils/InputLabel.d.ts

@@ -1,5 +1,5 @@
 import preact from "preact";
-type InputProps = (preact.JSX.HTMLAttributes<HTMLInputElement> & {
+export type InputProps = (preact.JSX.HTMLAttributes<HTMLInputElement> & {
     /** ONLY throttles onChangeValue */
     throttle?: number;
     flavor?: "large" | "small" | "none";
@@ -59,4 +59,3 @@ export declare class InputLabelURL extends preact.Component<InputLabelProps & {
 }> {
     render(): preact.JSX.Element;
 }
-export {};

package/render-utils/InputLabel.tsx

@@ -6,7 +6,7 @@ import { observer } from "./observer";
 import { observable } from "mobx";
 
 // IMPORTANT! InputProps is in both InputLabel.tsx and Input.tsx, so the types export correctly
-type InputProps = (
+export type InputProps = (
     preact.JSX.HTMLAttributes<HTMLInputElement>
     & {
         /** ONLY throttles onChangeValue */

package/render-utils/autoMeasure.d.ts

@@ -0,0 +1 @@
+export declare function runAutoMeasure(): void;

package/render-utils/autoMeasure.ts

@@ -0,0 +1,43 @@
+import { runInfinitePoll } from "socket-function/src/batching";
+import { timeInSecond } from "socket-function/src/misc";
+import { startMeasure, logMeasureTable } from "socket-function/src/profiling/measure";
+
+export function runAutoMeasure() {
+    let measureObj = startMeasure();
+
+    function logProfileMeasuresTimingsNow(force = false) {
+        let profile = measureObj.finish();
+        measureObj = startMeasure();
+        logMeasureTable(profile, {
+            name: `watchdog at ${new Date().toLocaleString()}`,
+            // NOTE: Much higher min log times, now that we are combining logs.
+            minTimeToLog: force ? 0 : 250,
+            thresholdInTable: 0,
+            setTitle: true
+        });
+        logMeasureTable(profile, {
+            name: `watchdog at ${new Date().toLocaleString()}`,
+            mergeDepth: 1,
+            minTimeToLog: force ? 0 : 250,
+        });
+    }
+    function logNow() {
+        logProfileMeasuresTimingsNow(true);
+    }
+    (globalThis as any).logProfileMeasuresNow = logNow;
+    (globalThis as any).logAll = logNow;
+    (globalThis as any).logNow = logNow;
+
+    (globalThis as any).logUnfiltered = function logUnfiltered(depth = 2) {
+        let profile = measureObj.finish();
+        measureObj = startMeasure();
+        logMeasureTable(profile, {
+            name: `all logs at ${new Date().toLocaleString()}`,
+            mergeDepth: depth,
+            minTimeToLog: 0,
+            maxTableEntries: 10000000,
+            thresholdInTable: 0
+        });
+    };
+    runInfinitePoll(timeInSecond * 60, logProfileMeasuresTimingsNow);
+}