sliftutils 1.1.4 → 1.1.40

package/index.d.ts

@@ -14,6 +14,7 @@ declare module "sliftutils/misc/apiKeys" {
         getAllKeys(): string[];
         get(key: string): Promise<string> | undefined;
     };
+    export declare function setAPIKey(key: string, value: string): void;
     export declare class ManageAPIKeys extends preact.Component {
         render(): string;
     }
@@ -155,6 +156,11 @@ declare module "sliftutils/misc/https/dns" {
 }
 
 declare module "sliftutils/misc/https/httpsCerts" {
+    /// <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<{
@@ -173,6 +179,18 @@ declare module "sliftutils/misc/https/httpsCerts" {
             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;
+    }>;
 
 }
 
@@ -228,6 +246,7 @@ declare module "sliftutils/misc/openrouter" {
     }[];
     export declare function getTotalCost(): number;
     type OpenRouterOptions = {
+        apiKey?: string;
         provider?: {
             sort?: "throughput" | "price" | "latency";
             order?: string[];
@@ -291,18 +310,8 @@ declare module "sliftutils/misc/yamlBase" {
 }
 
 declare module "sliftutils/misc/zip" {
-    /// <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 };
 
 }
 
@@ -452,7 +461,7 @@ declare module "sliftutils/render-utils/Input" {
 
 declare module "sliftutils/render-utils/InputLabel" {
     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";
@@ -512,7 +521,6 @@ declare module "sliftutils/render-utils/InputLabel" {
     }> {
         render(): preact.JSX.Element;
     }
-    export {};
 
 }
 
@@ -690,6 +698,11 @@ declare module "sliftutils/render-utils/asyncObservable" {
 
 }
 
+declare module "sliftutils/render-utils/autoMeasure" {
+    export declare function runAutoMeasure(): void;
+
+}
+
 declare module "sliftutils/render-utils/colors" {
     export declare const redButton: string;
     export declare const yellowButton: string;
@@ -802,6 +815,8 @@ declare module "sliftutils/storage/DiskCollection" {
     export declare class DiskCollection<T> implements IStorageSync<T> {
         private collectionName;
         private config?;
+        static getForceNoPrompt(): boolean;
+        static setForceNoPrompt(forceNoPrompt: boolean): void;
         constructor(collectionName: string, config?: {
             writeDelay?: number | undefined;
             cbor?: boolean | undefined;
@@ -863,6 +878,21 @@ declare module "sliftutils/storage/DiskCollection" {
         } | undefined>;
         reset(): Promise<void>;
     }
+    export declare class DiskCollectionRawSynced {
+        private collectionName;
+        constructor(collectionName: string);
+        initStorage(): Promise<IStorage<Buffer>>;
+        private synced;
+        get(key: string): Buffer | undefined;
+        getPromise(key: string): Promise<Buffer | undefined>;
+        set(key: string, value: Buffer): void;
+        getKeys(): Promise<string[]>;
+        getInfo(key: string): Promise<{
+            size: number;
+            lastModified: number;
+        } | undefined>;
+        reset(): Promise<void>;
+    }
     export declare class DiskCollectionRawBrowser {
         private collectionName;
         constructor(collectionName: string);
@@ -918,6 +948,9 @@ declare module "sliftutils/storage/FileFolderAPI" {
             size: number;
             lastModified: number;
             arrayBuffer(): Promise<ArrayBuffer>;
+            slice(start: number, end: number): {
+                arrayBuffer(): Promise<ArrayBuffer>;
+            };
         }>;
         createWritable(config?: {
             keepExistingData?: boolean;
@@ -1015,6 +1048,10 @@ declare module "sliftutils/storage/IStorage" {
     };
     export type IStorageRaw = {
         get(key: string): Promise<Buffer | undefined>;
+        getRange(key: string, config: {
+            start: number;
+            end: number;
+        }): Promise<Buffer | undefined>;
         append(key: string, value: Buffer): Promise<void>;
         set(key: string, value: Buffer): Promise<void>;
         remove(key: string): Promise<void>;
@@ -1106,6 +1143,10 @@ declare module "sliftutils/storage/PrivateFileSystemStorage" {
         private getFileHandle;
         private fileExists;
         get(key: string): Promise<Buffer | undefined>;
+        getRange(key: string, config: {
+            start: number;
+            end: number;
+        }): Promise<Buffer | undefined>;
         set(key: string, value: Buffer): Promise<void>;
         append(key: string, value: Buffer): Promise<void>;
         remove(key: string): Promise<void>;
@@ -1121,6 +1162,9 @@ declare module "sliftutils/storage/PrivateFileSystemStorage" {
 
 declare module "sliftutils/storage/StorageObservable" {
     import { IStorage, IStorageSync } from "./IStorage";
+    export declare const storagePendingAccesses: {
+        value: number;
+    };
     export declare class StorageSync<T> implements IStorageSync<T> {
         storage: IStorage<T>;
         private config?;
@@ -1160,6 +1204,13 @@ declare module "sliftutils/storage/StorageObservable" {
         reloadKey(key: string): void;
         reset(): Promise<void>;
     }
+    export declare function waitUntilNextLoad(): Promise<void>;
+
+}
+
+declare module "sliftutils/storage/StorageObservableAsync" {
+    /** Reruns the code until all StorageSyncs accessed have loaded their values. Not efficient,although will usually be O(values accessed), just due to how loading works (it won't be quadratic). */
+    export declare function rerunCodeUntilAllLoaded<T>(code: () => T): Promise<T>;
 
 }
 
@@ -1219,6 +1270,107 @@ declare module "sliftutils/storage/TransactionStorage" {
 
 }
 
+declare module "sliftutils/storage/backblaze" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export declare class ArchivesBackblaze {
+        private config;
+        constructor(config: {
+            bucketName: string;
+            public?: boolean;
+            immutable?: boolean;
+            cacheTime?: number;
+        });
+        private bucketName;
+        private bucketId;
+        private logging;
+        enableLogging(): void;
+        private log;
+        getDebugName(): string;
+        private getBucketAPI;
+        private last503Reset;
+        private apiRetryLogic;
+        get(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+            retryCount?: number;
+        }): Promise<Buffer | undefined>;
+        set(fileName: string, data: Buffer): Promise<void>;
+        del(fileName: string): Promise<void>;
+        setLargeFile(config: {
+            path: string;
+            getNextData(): Promise<Buffer | undefined>;
+        }): Promise<void>;
+        getInfo(fileName: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        find(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<string[]>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<{
+            path: string;
+            createTime: number;
+            size: number;
+        }[]>;
+        assertPathValid(path: string): Promise<void>;
+        getURL(path: string): Promise<string>;
+        getDownloadAuthorization(config: {
+            fileNamePrefix?: string;
+            validDurationInSeconds: number;
+            b2ContentDisposition?: string;
+            b2ContentLanguage?: string;
+            b2Expires?: string;
+            b2CacheControl?: string;
+            b2ContentEncoding?: string;
+            b2ContentType?: string;
+        }): Promise<{
+            bucketId: string;
+            fileNamePrefix: string;
+            authorizationToken: string;
+        }>;
+    }
+    export declare const getArchivesBackblaze: {
+        (key: string): ArchivesBackblaze;
+        clear(key: string): void;
+        clearAll(): void;
+        forceSet(key: string, value: ArchivesBackblaze): void;
+        getAllKeys(): string[];
+        get(key: string): ArchivesBackblaze | undefined;
+    };
+    export declare const getArchivesBackblazePrivateImmutable: {
+        (key: string): ArchivesBackblaze;
+        clear(key: string): void;
+        clearAll(): void;
+        forceSet(key: string, value: ArchivesBackblaze): void;
+        getAllKeys(): string[];
+        get(key: string): ArchivesBackblaze | undefined;
+    };
+    export declare const getArchivesBackblazePublicImmutable: {
+        (key: string): ArchivesBackblaze;
+        clear(key: string): void;
+        clearAll(): void;
+        forceSet(key: string, value: ArchivesBackblaze): void;
+        getAllKeys(): string[];
+        get(key: string): ArchivesBackblaze | undefined;
+    };
+    export declare const getArchivesBackblazePublic: {
+        (key: string): ArchivesBackblaze;
+        clear(key: string): void;
+        clearAll(): void;
+        forceSet(key: string, value: ArchivesBackblaze): void;
+        getAllKeys(): string[];
+        get(key: string): ArchivesBackblaze | undefined;
+    };
+
+}
+
 declare module "sliftutils/storage/fileSystemPointer" {
     export type FileSystemPointer = string;
     export declare function storeFileSystemPointer(config: {

package/misc/apiKeys.d.ts

@@ -10,6 +10,7 @@ export declare const getAPIKey: {
     getAllKeys(): string[];
     get(key: string): Promise<string> | undefined;
 };
+export declare function setAPIKey(key: string, value: string): void;
 export declare class ManageAPIKeys extends preact.Component {
     render(): string;
 }

package/misc/apiKeys.tsx

@@ -128,15 +128,19 @@ export const getAPIKey = cache(async function getAPIKey(key: string): Promise<st
     try {
         let value = await promise;
 
-        getStorage().setItem(keyKey, value);
-        state.keys.push(key);
-        getStorage().setItem(getStorageKey("__keys"), JSON.stringify(state.keys));
+        setAPIKey(key, value);
         return value;
     } finally {
         obj.close();
     }
 });
 
+export function setAPIKey(key: string, value: string) {
+    getStorage().setItem(getStorageKey(key), value);
+    state.keys.push(key);
+    getStorage().setItem(getStorageKey("__keys"), JSON.stringify(state.keys));
+}
+
 @observer
 export class ManageAPIKeys extends preact.Component {
     render() {

package/misc/dist/apiKeys.tsx.cache

@@ -0,0 +1,145 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.ManageAPIKeys = exports.setAPIKey = exports.getAPIKey = exports.APIKeysControl = void 0;
+const preact_1 = __importDefault(require("preact"));
+const caching_1 = require("socket-function/src/caching");
+const typesafecss_1 = require("typesafecss");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const mobx_1 = require("mobx");
+const InputLabel_1 = require("../render-utils/InputLabel");
+const modal_1 = require("../render-utils/modal");
+const observer_1 = require("../render-utils/observer");
+let DirectoryPrompter = class DirectoryPrompter extends preact_1.default.Component {
+    constructor() {
+        super(...arguments);
+        this.synced = (0, mobx_1.observable)({
+            value: "",
+        });
+    }
+    render() {
+        const { valueKey, onDone } = this.props;
+        const { value } = this.synced;
+        return (preact_1.default.createElement("div", { className: typesafecss_1.css.position("fixed").pos(0, 0).size("100vw", "100vh")
+                .zIndex(1)
+                .hsla(0, 0, 20, 0.5)
+                .center
+                .fontSize(40) },
+            preact_1.default.createElement(InputLabel_1.InputLabel, { label: valueKey, value: value, onChangeValue: value => this.synced.value = value }),
+            preact_1.default.createElement("button", { onClick: () => onDone(value) }, "Done")));
+    }
+};
+DirectoryPrompter = __decorate([
+    observer_1.observer
+], DirectoryPrompter);
+function getStorageKey(key) {
+    if ((0, typesafecss_1.isNode)())
+        return os_1.default.homedir() + "/" + key;
+    return `apiKeys.ts_${key}`;
+}
+let state = (0, mobx_1.observable)({
+    keys: [],
+});
+if (!(0, typesafecss_1.isNode)()) {
+    try {
+        let newKeys = JSON.parse(localStorage.getItem(getStorageKey("__keys")));
+        if (Array.isArray(newKeys)) {
+            state.keys = newKeys;
+        }
+    }
+    catch (_a) { }
+}
+let APIKeysControl = class APIKeysControl extends preact_1.default.Component {
+    render() {
+        return (preact_1.default.createElement("label", { className: typesafecss_1.css.hbox(4) },
+            preact_1.default.createElement("span", null, "Keys:"),
+            preact_1.default.createElement("select", null, state.keys.map(key => preact_1.default.createElement("option", null, key))),
+            preact_1.default.createElement("button", { onClick: () => {
+                    let key = state.keys[0];
+                    state.keys = state.keys.filter(k => k !== key);
+                    localStorage.setItem(getStorageKey("__keys"), JSON.stringify(state.keys));
+                    localStorage.removeItem(getStorageKey(key));
+                } }, "Delete")));
+    }
+};
+exports.APIKeysControl = APIKeysControl;
+exports.APIKeysControl = APIKeysControl = __decorate([
+    observer_1.observer
+], APIKeysControl);
+let getStorage = (0, caching_1.lazy)(() => {
+    if (!(0, typesafecss_1.isNode)())
+        return localStorage;
+    return {
+        getItem: (key) => {
+            if (!fs_1.default.existsSync(key))
+                return null;
+            return fs_1.default.readFileSync(key, "utf-8");
+        },
+        setItem: (key, value) => {
+            fs_1.default.writeFileSync(key, value);
+        },
+    };
+});
+exports.getAPIKey = (0, caching_1.cache)(async function getAPIKey(key) {
+    let innerKey = "key";
+    if ((0, typesafecss_1.isNode)()) {
+        if (key.includes(".json.")) {
+            let [baseKey, innerKeyPart] = key.split(".json.");
+            baseKey += ".json";
+            innerKey = innerKeyPart;
+            key = baseKey;
+        }
+    }
+    let keyKey = getStorageKey(key);
+    let localStorageValue = getStorage().getItem(keyKey);
+    if (localStorageValue === null || localStorageValue === void 0 ? void 0 : localStorageValue.startsWith("{")) {
+        try {
+            localStorageValue = JSON.parse(localStorageValue)[innerKey];
+        }
+        catch (_a) { }
+    }
+    if (localStorageValue) {
+        return localStorageValue;
+    }
+    if ((0, typesafecss_1.isNode)())
+        throw new Error(`Add an api key to ${keyKey}`);
+    let onDone = (value) => { };
+    let promise = new Promise(resolve => {
+        onDone = resolve;
+    });
+    let obj = (0, modal_1.showModal)({ contents: preact_1.default.createElement(DirectoryPrompter, { valueKey: key, onDone: onDone }) });
+    try {
+        let value = await promise;
+        setAPIKey(key, value);
+        return value;
+    }
+    finally {
+        obj.close();
+    }
+});
+function setAPIKey(key, value) {
+    getStorage().setItem(getStorageKey(key), value);
+    state.keys.push(key);
+    getStorage().setItem(getStorageKey("__keys"), JSON.stringify(state.keys));
+}
+exports.setAPIKey = setAPIKey;
+let ManageAPIKeys = class ManageAPIKeys extends preact_1.default.Component {
+    render() {
+        return "ManageAPIKeys";
+    }
+};
+exports.ManageAPIKeys = ManageAPIKeys;
+exports.ManageAPIKeys = ManageAPIKeys = __decorate([
+    observer_1.observer
+], ManageAPIKeys);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apiKeys.js","sourceRoot":"","sources":["apiKeys.tsx"],"names":[],"mappings":";;;;;;;;;;;;AAAA,oDAA4B;AAC5B,yDAA0D;AAC1D,6CAA0C;AAC1C,4CAAoB;AACpB,4CAAoB;AACpB,+BAAkC;AAClC,2DAAwD;AACxD,iDAAkD;AAClD,uDAAoD;AAGpD,IAAM,iBAAiB,GAAvB,MAAM,iBAAkB,SAAQ,gBAAM,CAAC,SAGrC;IAHF;;QAII,WAAM,GAAG,IAAA,iBAAU,EAAC;YAChB,KAAK,EAAE,EAAE;SACZ,CAAC,CAAC;IAuBP,CAAC;IAtBG,MAAM;QACF,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;QACxC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC;QAC9B,OAAO,CACH,wCAAK,SAAS,EACV,iBAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC;iBACjD,MAAM,CAAC,CAAC,CAAC;iBACT,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,GAAG,CAAC;iBACnB,MAAM;iBACN,QAAQ,CAAC,EAAE,CAAC;YAEjB,+BAAC,uBAAU,IACP,KAAK,EAAE,QAAQ,EACf,KAAK,EAAE,KAAK,EACZ,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,KAAK,GACnD;YACF,2CAAQ,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,WAE3B,CACP,CACT,CAAC;IACN,CAAC;CACJ,CAAA;AA7BK,iBAAiB;IADtB,mBAAQ;GACH,iBAAiB,CA6BtB;AAGD,SAAS,aAAa,CAAC,GAAW;IAC9B,IAAI,IAAA,oBAAM,GAAE;QAAE,OAAO,YAAE,CAAC,OAAO,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;IAC9C,OAAO,cAAc,GAAG,EAAE,CAAC;AAC/B,CAAC;AAED,IAAI,KAAK,GAAG,IAAA,iBAAU,EAAC;IACnB,IAAI,EAAE,EAAc;CACvB,CAAC,CAAC;AACH,IAAI,CAAC,IAAA,oBAAM,GAAE,EAAE,CAAC;IACZ,IAAI,CAAC;QACD,IAAI,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAE,CAAC,CAAC;QACzE,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACzB,KAAK,CAAC,IAAI,GAAG,OAAO,CAAC;QACzB,CAAC;IACL,CAAC;IAAC,WAAM,CAAC,CAAC,CAAC;AACf,CAAC;AAGM,IAAM,cAAc,GAApB,MAAM,cAAe,SAAQ,gBAAM,CAAC,SAAS;IAChD,MAAM;QACF,OAAO,CACH,0CAAO,SAAS,EAAE,iBAAG,CAAC,IAAI,CAAC,CAAC,CAAC;YACzB,qDAAkB;YAClB,+CACK,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAClB,+CAAS,GAAG,CAAU,CACzB,CACI;YACT,2CAAQ,OAAO,EAAE,GAAG,EAAE;oBAClB,IAAI,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;oBACxB,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC;oBAC/C,YAAY,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;oBAC1E,YAAY,CAAC,UAAU,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;gBAChD,CAAC,aAEQ,CACL,CACX,CAAC;IACN,CAAC;CACJ,CAAA;AArBY,wCAAc;yBAAd,cAAc;IAD1B,mBAAQ;GACI,cAAc,CAqB1B;AAED,IAAI,UAAU,GAAG,IAAA,cAAI,EAAC,GAGpB,EAAE;IACA,IAAI,CAAC,IAAA,oBAAM,GAAE;QAAE,OAAO,YAAY,CAAC;IACnC,OAAO;QACH,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;YACb,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,GAAG,CAAC;gBAAE,OAAO,IAAI,CAAC;YACrC,OAAO,YAAE,CAAC,YAAY,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QACzC,CAAC;QACD,OAAO,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE;YACpB,YAAE,CAAC,aAAa,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACjC,CAAC;KACJ,CAAC;AACN,CAAC,CAAC,CAAC;AAEU,QAAA,SAAS,GAAG,IAAA,eAAK,EAAC,KAAK,UAAU,SAAS,CAAC,GAAW;IAC/D,IAAI,QAAQ,GAAG,KAAK,CAAC;IACrB,IAAI,IAAA,oBAAM,GAAE,EAAE,CAAC;QACX,IAAI,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzB,IAAI,CAAC,OAAO,EAAE,YAAY,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;YAClD,OAAO,IAAI,OAAO,CAAC;YACnB,QAAQ,GAAG,YAAY,CAAC;YACxB,GAAG,GAAG,OAAO,CAAC;QAClB,CAAC;IACL,CAAC;IACD,IAAI,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IAChC,IAAI,iBAAiB,GAAG,UAAU,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACrD,IAAI,iBAAiB,aAAjB,iBAAiB,uBAAjB,iBAAiB,CAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QACrC,IAAI,CAAC;YACD,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC,CAAC;QAChE,CAAC;QAAC,WAAM,CAAC,CAAC,CAAC;IACf,CAAC;IACD,IAAI,iBAAiB,EAAE,CAAC;QACpB,OAAO,iBAAiB,CAAC;IAC7B,CAAC;IACD,IAAI,IAAA,oBAAM,GAAE;QAAE,MAAM,IAAI,KAAK,CAAC,qBAAqB,MAAM,EAAE,CAAC,CAAC;IAE7D,IAAI,MAAM,GAAG,CAAC,KAAa,EAAE,EAAE,GAAG,CAAC,CAAC;IACpC,IAAI,OAAO,GAAG,IAAI,OAAO,CAAS,OAAO,CAAC,EAAE;QACxC,MAAM,GAAG,OAAO,CAAC;IACrB,CAAC,CAAC,CAAC;IACH,IAAI,GAAG,GAAG,IAAA,iBAAS,EAAC,EAAE,QAAQ,EAAE,+BAAC,iBAAiB,IAAC,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,GAAI,EAAE,CAAC,CAAC;IACxF,IAAI,CAAC;QACD,IAAI,KAAK,GAAG,MAAM,OAAO,CAAC;QAE1B,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QACtB,OAAO,KAAK,CAAC;IACjB,CAAC;YAAS,CAAC;QACP,GAAG,CAAC,KAAK,EAAE,CAAC;IAChB,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,SAAgB,SAAS,CAAC,GAAW,EAAE,KAAa;IAChD,UAAU,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;IAChD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACrB,UAAU,EAAE,CAAC,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;AAC9E,CAAC;AAJD,8BAIC;AAGM,IAAM,aAAa,GAAnB,MAAM,aAAc,SAAQ,gBAAM,CAAC,SAAS;IAC/C,MAAM;QACF,OAAO,eAAe,CAAC;IAC3B,CAAC;CACJ,CAAA;AAJY,sCAAa;wBAAb,aAAa;IADzB,mBAAQ;GACI,aAAa,CAIzB","sourcesContent":["import preact from \"preact\";\nimport { cache, lazy } from \"socket-function/src/caching\";\nimport { css, isNode } from \"typesafecss\";\nimport fs from \"fs\";\nimport os from \"os\";\nimport { observable } from \"mobx\";\nimport { InputLabel } from \"../render-utils/InputLabel\";\nimport { showModal } from \"../render-utils/modal\";\nimport { observer } from \"../render-utils/observer\";\n\n@observer\nclass DirectoryPrompter extends preact.Component<{\n    valueKey: string;\n    onDone: (value: string) => void;\n}> {\n    synced = observable({\n        value: \"\",\n    });\n    render() {\n        const { valueKey, onDone } = this.props;\n        const { value } = this.synced;\n        return (\n            <div className={\n                css.position(\"fixed\").pos(0, 0).size(\"100vw\", \"100vh\")\n                    .zIndex(1)\n                    .hsla(0, 0, 20, 0.5)\n                    .center\n                    .fontSize(40)\n            }>\n                <InputLabel\n                    label={valueKey}\n                    value={value}\n                    onChangeValue={value => this.synced.value = value}\n                />\n                <button onClick={() => onDone(value)}>\n                    Done\n                </button>\n            </div>\n        );\n    }\n}\n\n\nfunction getStorageKey(key: string) {\n    if (isNode()) return os.homedir() + \"/\" + key;\n    return `apiKeys.ts_${key}`;\n}\n\nlet state = observable({\n    keys: [] as string[],\n});\nif (!isNode()) {\n    try {\n        let newKeys = JSON.parse(localStorage.getItem(getStorageKey(\"__keys\"))!);\n        if (Array.isArray(newKeys)) {\n            state.keys = newKeys;\n        }\n    } catch { }\n}\n\n@observer\nexport class APIKeysControl extends preact.Component {\n    render() {\n        return (\n            <label className={css.hbox(4)}>\n                <span>Keys:</span>\n                <select>\n                    {state.keys.map(key =>\n                        <option>{key}</option>\n                    )}\n                </select>\n                <button onClick={() => {\n                    let key = state.keys[0];\n                    state.keys = state.keys.filter(k => k !== key);\n                    localStorage.setItem(getStorageKey(\"__keys\"), JSON.stringify(state.keys));\n                    localStorage.removeItem(getStorageKey(key));\n                }}>\n                    Delete\n                </button>\n            </label>\n        );\n    }\n}\n\nlet getStorage = lazy((): {\n    getItem: (key: string) => string | null;\n    setItem: (key: string, value: string) => void;\n} => {\n    if (!isNode()) return localStorage;\n    return {\n        getItem: (key) => {\n            if (!fs.existsSync(key)) return null;\n            return fs.readFileSync(key, \"utf-8\");\n        },\n        setItem: (key, value) => {\n            fs.writeFileSync(key, value);\n        },\n    };\n});\n\nexport const getAPIKey = cache(async function getAPIKey(key: string): Promise<string> {\n    let innerKey = \"key\";\n    if (isNode()) {\n        if (key.includes(\".json.\")) {\n            let [baseKey, innerKeyPart] = key.split(\".json.\");\n            baseKey += \".json\";\n            innerKey = innerKeyPart;\n            key = baseKey;\n        }\n    }\n    let keyKey = getStorageKey(key);\n    let localStorageValue = getStorage().getItem(keyKey);\n    if (localStorageValue?.startsWith(\"{\")) {\n        try {\n            localStorageValue = JSON.parse(localStorageValue)[innerKey];\n        } catch { }\n    }\n    if (localStorageValue) {\n        return localStorageValue;\n    }\n    if (isNode()) throw new Error(`Add an api key to ${keyKey}`);\n\n    let onDone = (value: string) => { };\n    let promise = new Promise<string>(resolve => {\n        onDone = resolve;\n    });\n    let obj = showModal({ contents: <DirectoryPrompter valueKey={key} onDone={onDone} /> });\n    try {\n        let value = await promise;\n\n        setAPIKey(key, value);\n        return value;\n    } finally {\n        obj.close();\n    }\n});\n\nexport function setAPIKey(key: string, value: string) {\n    getStorage().setItem(getStorageKey(key), value);\n    state.keys.push(key);\n    getStorage().setItem(getStorageKey(\"__keys\"), JSON.stringify(state.keys));\n}\n\n@observer\nexport class ManageAPIKeys extends preact.Component {\n    render() {\n        return \"ManageAPIKeys\";\n    }\n}"]}
+ /* _JS_SOURCE_HASH = "d6ef02866d39c57a55ce88d8e6b03ddc399584de91fdd66b6aab0198cbab4c70"; */

package/misc/dist/openrouter.ts.cache

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.openRouterCallBase = exports.openRouterCall = exports.simpleAICallTyped = exports.simpleAICall = exports.yamlOpenRouterCall = exports.getTotalCost = void 0;
+const yaml_1 = require("./yaml");
+const batching_1 = require("socket-function/src/batching");
+const format_1 = require("socket-function/src/formatting/format");
+const apiKeys_1 = require("./apiKeys");
+let totalCost = 0;
+function getTotalCost() {
+    return totalCost;
+}
+exports.getTotalCost = getTotalCost;
+/** IMPORTANT! Make sure to tell the AI to return yaml. */
+async function yamlOpenRouterCall(config) {
+    var _a;
+    let { model, messages, retries = 3, options, onCost } = config;
+    try {
+        let response = await openRouterCall({ model, messages, options, onCost, retries: 0 });
+        let result = (0, yaml_1.parseYAML)(response);
+        (_a = config.validate) === null || _a === void 0 ? void 0 : _a.call(config, result);
+        return result;
+    }
+    catch (error) {
+        if (retries > 0) {
+            return yamlOpenRouterCall({ model, messages, retries: retries - 1, onCost });
+        }
+        throw error;
+    }
+}
+exports.yamlOpenRouterCall = yamlOpenRouterCall;
+async function simpleAICall(model, message) {
+    return await openRouterCallBase({
+        model,
+        messages: [{ role: "user", content: message }],
+    });
+}
+exports.simpleAICall = simpleAICall;
+/** The message must request the result to be returned in YAML (we automatically parse this and return an object). */
+async function simpleAICallTyped(model, message) {
+    return await yamlOpenRouterCall({
+        model,
+        messages: [{ role: "user", content: message }],
+    });
+}
+exports.simpleAICallTyped = simpleAICallTyped;
+let pendingLog = undefined;
+async function openRouterCall(config) {
+    return await openRouterCallBase(config);
+}
+exports.openRouterCall = openRouterCall;
+async function openRouterCallBase(config) {
+    let { model, messages, options, onCost } = config;
+    let openrouterKey = (options === null || options === void 0 ? void 0 : options.apiKey) || await (0, apiKeys_1.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));
+            if (stillRunning) {
+                console.log("OpenRouter call still running...");
+            }
+        }
+    })();
+    try {
+        return await (0, batching_1.retryFunctional)(async () => {
+            let response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${openrouterKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model,
+                    messages,
+                    provider: {
+                        sort: "throughput",
+                    },
+                    usage: { include: true },
+                    ...options,
+                }),
+            });
+            // 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}`);
+            }
+            let responseObj = await response.json();
+            let newCost = responseObj.usage.cost;
+            totalCost += newCost;
+            onCost === null || onCost === void 0 ? void 0 : onCost(newCost);
+            if (!pendingLog) {
+                pendingLog = {
+                    count: 0,
+                    duration: 0,
+                    cost: 0,
+                };
+                setTimeout(() => {
+                    let log = pendingLog;
+                    if (!log)
+                        return;
+                    console.log(`Ran: ${log.count} calls at a total summed cost of ${(0, format_1.formatNumber)(1 / log.cost)}/USD`);
+                    pendingLog = undefined;
+                }, 10000);
+            }
+            pendingLog.count++;
+            pendingLog.duration += Date.now() - time;
+            pendingLog.cost += newCost;
+            return responseObj.choices[0].message.content;
+        }, { maxRetries: config.retries || 3 })();
+    }
+    finally {
+        stillRunning = false;
+    }
+}
+exports.openRouterCallBase = openRouterCallBase;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openrouter.js","sourceRoot":"","sources":["openrouter.ts"],"names":[],"mappings":"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","sourcesContent":["import { parseYAML } from \"./yaml\";\nimport { retryFunctional } from \"socket-function/src/batching\";\nimport { formatNumber } from \"socket-function/src/formatting/format\";\nimport { getAPIKey } from \"./apiKeys\";\n\nexport type MessageHistory = {\n    role: \"system\" | \"user\" | \"assistant\";\n    content: string;\n}[];\nexport type MessageHistory2 = {\n    role: \"system\" | \"user\" | \"assistant\";\n    content: string | {\n        type: \"image_url\";\n        image_url: {\n            url: string;\n        };\n    }[];\n}[];\n\nlet totalCost = 0;\nexport function getTotalCost() {\n    return totalCost;\n}\ntype OpenRouterOptions = {\n    // 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.\n    apiKey?: string;\n    provider?: {\n        sort?: \"throughput\" | \"price\" | \"latency\",\n        // https://openrouter.ai/docs/features/provider-routing#ordering-specific-providers\n        order?: string[],\n    }\n    reasoningEffort?: \"low\" | \"medium\" | \"high\",\n};\n/** IMPORTANT! Make sure to tell the AI to return yaml. */\nexport async function yamlOpenRouterCall<T>(config: {\n    model: string;\n    messages: MessageHistory;\n    retries?: number;\n    options?: OpenRouterOptions;\n    onCost?: (cost: number) => void;\n    validate?: (response: T) => void;\n}): Promise<T> {\n    let { model, messages, retries = 3, options, onCost } = config;\n    try {\n        let response = await openRouterCall({ model, messages, options, onCost, retries: 0 });\n        let result = parseYAML(response) as T;\n        config.validate?.(result);\n        return result;\n    } catch (error) {\n        if (retries > 0) {\n            return yamlOpenRouterCall<T>({ model, messages, retries: retries - 1, onCost });\n        }\n        throw error;\n    }\n}\n\nexport async function simpleAICall(model: string, message: string): Promise<string> {\n    return await openRouterCallBase({\n        model,\n        messages: [{ role: \"user\", content: message }],\n    });\n}\n/** The message must request the result to be returned in YAML (we automatically parse this and return an object). */\nexport async function simpleAICallTyped<T>(model: string, message: string): Promise<T> {\n    return await yamlOpenRouterCall({\n        model,\n        messages: [{ role: \"user\", content: message }],\n    }) as T;\n}\n\nlet pendingLog: {\n    count: number;\n    duration: number;\n    cost: number;\n} | undefined = undefined;\n\nexport async function openRouterCall(config: {\n    model: string;\n    messages: MessageHistory;\n    options?: OpenRouterOptions;\n    onCost?: (cost: number) => void;\n    retries?: number;\n}): Promise<string> {\n    return await openRouterCallBase(config);\n}\n\nexport async function openRouterCallBase(config: {\n    model: string;\n    messages: MessageHistory2;\n    options?: OpenRouterOptions;\n    onCost?: (cost: number) => void;\n    retries?: number;\n}): Promise<string> {\n    let { model, messages, options, onCost } = config;\n    let openrouterKey = options?.apiKey || await getAPIKey(\"openrouter.json\");\n    console.log(`Calling ${model} with ${messages.length} messages`);\n    let time = Date.now();\n    let stillRunning = true;\n\n    // Spawn monitoring loop\n    void (async () => {\n        while (stillRunning) {\n            await new Promise(resolve => setTimeout(resolve, 5000));\n            if (stillRunning) {\n                console.log(\"OpenRouter call still running...\");\n            }\n        }\n    })();\n\n    try {\n        return await retryFunctional(async () => {\n            let response = await fetch(\"https://openrouter.ai/api/v1/chat/completions\", {\n                method: \"POST\",\n                headers: {\n                    \"Authorization\": `Bearer ${openrouterKey}`,\n                    \"Content-Type\": \"application/json\",\n                },\n                body: JSON.stringify({\n                    model,\n                    messages,\n                    provider: {\n                        sort: \"throughput\",\n                    },\n                    usage: { include: true },\n                    ...options,\n                }),\n            });\n\n            // If it failed, throw\n            if (response.status !== 200) {\n                let responseText = await response.text();\n                throw new Error(`Failed to call OpenRouter: ${response.status} ${response.statusText} ${responseText}`);\n            }\n            let responseObj = await response.json() as {\n                usage: {\n                    cost: number;\n                };\n                choices: {\n                    message: {\n                        content: string;\n                    };\n                }[];\n            };\n            let newCost = responseObj.usage.cost;\n            totalCost += newCost;\n            onCost?.(newCost);\n            if (!pendingLog) {\n                pendingLog = {\n                    count: 0,\n                    duration: 0,\n                    cost: 0,\n                };\n                setTimeout(() => {\n                    let log = pendingLog;\n                    if (!log) return;\n                    console.log(`Ran: ${log.count} calls at a total summed cost of ${formatNumber(1 / log.cost)}/USD`);\n                    pendingLog = undefined;\n                }, 10_000);\n            }\n            pendingLog.count++;\n            pendingLog.duration += Date.now() - time;\n            pendingLog.cost += newCost;\n            return responseObj.choices[0].message.content as string;\n        }, { maxRetries: config.retries || 3 })();\n    } finally {\n        stillRunning = false;\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "29f9508fae589e294847d9f6787f804824093b8193621bf6749e0cde3607329d"; */