querysub 0.378.0 → 0.379.0

package/src/diagnostics/logs/errorNotifications2/errorWatcher.ts

@@ -0,0 +1,168 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { lazy } from "socket-function/src/caching";
+import { nextId } from "socket-function/src/misc";
+import { t } from "../../../2-proxy/schema2";
+import { Querysub } from "../../../4-querysub/QuerysubController";
+import { LogDatum } from "../diskLogger";
+import { SuppressionMatch, watchUnmatchedErrors, ErrorNotificationsController } from "./errorNotifications";
+
+let errorNotificationsLocalSchema = Querysub.createLocalSchema("errorNotifications", {
+    unmatchedErrors: t.atomic<LogDatum[]>([]),
+    suppressionMatches: t.atomic<Map<string, SuppressionMatch>>(new Map()),
+    suppressionEntries: t.atomic<Array<{
+        id: string;
+        notes?: string;
+        pattern: string;
+        timeout: number;
+        createdTime: number;
+        lastUpdatedTime: number;
+    }>>([]),
+    isLoading: t.atomic<boolean>(true),
+    initError: t.atomic<string | undefined>(undefined),
+});
+
+export let getErrorNotificationsManager = lazy(() => {
+    let state = errorNotificationsLocalSchema();
+
+    void (async () => {
+        try {
+            await watchUnmatchedErrors({
+                errorCallback: (datums: LogDatum[]) => {
+                    Querysub.commit(() => {
+                        state.unmatchedErrors = [...state.unmatchedErrors, ...datums];
+                    });
+                },
+                suppressionCallback: (matches) => {
+                    Querysub.commit(() => {
+                        let newMatches = new Map(state.suppressionMatches);
+                        let hasNewSuppression = false;
+                        for (let match of matches) {
+                            newMatches.set(match.id, match);
+                            if (!state.suppressionEntries.find(e => e.id === match.id)) {
+                                hasNewSuppression = true;
+                            }
+                        }
+                        state.suppressionMatches = newMatches;
+                        if (hasNewSuppression) {
+                            void reloadData();
+                        }
+                    });
+                },
+            });
+
+            let controller = ErrorNotificationsController(SocketFunction.browserNodeId());
+            let data = await controller.getData.promise();
+            let suppressionEntries = await controller.getSuppressionEntries.promise();
+
+            Querysub.commit(() => {
+                state.unmatchedErrors = data.unmatchedErrors;
+                state.suppressionMatches = data.suppressionMatches;
+                state.suppressionEntries = suppressionEntries;
+                state.initError = undefined;
+                state.isLoading = false;
+            });
+        } catch (error) {
+            Querysub.commit(() => {
+                state.initError = error instanceof Error && error.message || String(error);
+                state.isLoading = false;
+            });
+        }
+    })();
+
+    async function reloadData() {
+        let controller = ErrorNotificationsController(SocketFunction.browserNodeId());
+        let data = await controller.getData.promise();
+        let suppressionEntries = await controller.getSuppressionEntries.promise();
+        Querysub.commit(() => {
+            state.unmatchedErrors = data.unmatchedErrors;
+            state.suppressionMatches = data.suppressionMatches;
+            state.suppressionEntries = suppressionEntries;
+        });
+    }
+
+    return {
+        state,
+        async addSuppression(pattern: string, timeout: number) {
+            if (!pattern) {
+                throw new Error("Pattern is required");
+            }
+
+            let now = Date.now();
+            let newEntry = {
+                id: nextId(),
+                pattern,
+                timeout,
+                createdTime: now,
+                lastUpdatedTime: now,
+            };
+            let controller = ErrorNotificationsController(SocketFunction.browserNodeId());
+            await controller.setSuppressionEntry.promise(newEntry);
+            await reloadData();
+        },
+        async updateSuppression(id: string, pattern: string) {
+            if (!pattern) {
+                throw new Error("Pattern is required");
+            }
+
+            const existingEntry = Querysub.fastRead(() => state.suppressionEntries.find((s: { id: string; }) => s.id === id));
+            if (!existingEntry) {
+                throw new Error(`Suppression with id ${id} not found`);
+            }
+
+            let updatedEntry = {
+                id: existingEntry.id,
+                notes: existingEntry.notes,
+                pattern,
+                timeout: existingEntry.timeout,
+                createdTime: existingEntry.createdTime,
+                lastUpdatedTime: Date.now(),
+            };
+            let controller = ErrorNotificationsController(SocketFunction.browserNodeId());
+            await controller.setSuppressionEntry.promise(updatedEntry);
+            await reloadData();
+        },
+        async updateNotes(id: string, notes: string | undefined) {
+            const existingEntry = Querysub.fastRead(() => state.suppressionEntries.find((s: { id: string; }) => s.id === id));
+            if (!existingEntry) {
+                throw new Error(`Suppression with id ${id} not found`);
+            }
+
+            Querysub.commit(() => {
+                const idx = state.suppressionEntries.findIndex((s: { id: string; }) => s.id === id);
+                if (idx !== -1) {
+                    let updated = [...state.suppressionEntries];
+                    updated[idx] = { ...updated[idx], notes, lastUpdatedTime: Date.now() };
+                    state.suppressionEntries = updated;
+                }
+            });
+
+            let controller = ErrorNotificationsController(SocketFunction.browserNodeId());
+            await controller.updateSuppressionNotes.promise(id, notes);
+        },
+        async updateTimeout(id: string, timeout: number) {
+            const existingEntry = Querysub.fastRead(() => state.suppressionEntries.find((s: { id: string; }) => s.id === id));
+            if (!existingEntry) {
+                throw new Error(`Suppression with id ${id} not found`);
+            }
+
+            let updatedEntry = {
+                ...existingEntry,
+                timeout,
+                lastUpdatedTime: Date.now(),
+            };
+
+            let controller = ErrorNotificationsController(SocketFunction.browserNodeId());
+            await controller.setSuppressionEntry.promise(updatedEntry);
+            await reloadData();
+        },
+        async deleteSuppression(id: string) {
+            let controller = ErrorNotificationsController(SocketFunction.browserNodeId());
+            await controller.deleteSuppressionEntry.promise(id);
+            await reloadData();
+        },
+        async logTestError(message: string) {
+            let controller = ErrorNotificationsController(SocketFunction.browserNodeId());
+            await controller.logTestError.promise(message);
+        },
+    };
+});

package/src/diagnostics/logs/errorNotifications2/openRouterHelper.ts

@@ -0,0 +1,77 @@
+export async function callOpenRouter(apiKey: string, prompt: string): Promise<string> {
+    const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+        method: "POST",
+        headers: {
+            "Authorization": `Bearer ${apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            model: "google/gemini-3-flash-preview",
+            messages: [
+                {
+                    role: "user",
+                    content: prompt,
+                },
+            ],
+        }),
+    });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`OpenRouter API error: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+
+    const data = await response.json();
+
+    if (!data.choices || !data.choices[0] || !data.choices[0].message || !data.choices[0].message.content) {
+        throw new Error(`Unexpected OpenRouter API response format: ${JSON.stringify(data)}`);
+    }
+
+    return data.choices[0].message.content.trim();
+}
+
+export async function callOpenRouterJSON<T>(apiKey: string, prompt: string): Promise<T> {
+    const maxRetries = 3;
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${apiKey}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    model: "google/gemini-3-flash-preview",
+                    messages: [
+                        {
+                            role: "user",
+                            content: prompt,
+                        },
+                    ],
+                    response_format: { type: "json_object" },
+                }),
+            });
+
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`OpenRouter API error: ${response.status} ${response.statusText} - ${errorText}`);
+            }
+
+            const data = await response.json();
+
+            if (!data.choices || !data.choices[0] || !data.choices[0].message || !data.choices[0].message.content) {
+                throw new Error(`Unexpected OpenRouter API response format: ${JSON.stringify(data)}`);
+            }
+
+            const content = data.choices[0].message.content.trim();
+            const parsed = JSON.parse(content) as T;
+            return parsed;
+        } catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+        }
+    }
+
+    throw new Error(`Failed after ${maxRetries} attempts: ${lastError?.message}`);
+}

package/src/diagnostics/logs/lifeCycleAnalysis/lifeCycles.tsx

@@ -22,41 +22,12 @@ IMPORTANT! Now I am properly calling shutdown, so none of the streamed logs shou
 
 //todonext
 
-
-1) Add button that will log an error serverside, to ensure this system works
-    - Allow typing any error we want
-2) Write smaller component just for watching
-    - Lazily the component, and only if super user (just uncomment the code in Page.tsx)
-
-3) Fix up the error watching UI
-
-
-4) Publish
-
 5) Deploy watcher service to remote (yarn error-watch-public)
+6) Deploy CYOA
 
 5) Test on actual server, with actual logs
 
 
-// single service, no history search, discord messaging, suppression and suppression page
-//  - Storing suppression history just in memory? (although suppression values, obviously, on disk)
-//  - receive all errors, and service will do suppression
-
-// Start with page itself showing errors and suppressing them, for debugging/testing
-// - Ai to automatically create suppression searches, and combine existing ones, etc
-
-
-Rewrite error notification code
-    - Single service, which talks to all machines
-        - We'll have a dev mode, mostly for testing, although we won't usually run it.
-        - BROADCASTS messages to all http servers so they show them
-            - Broadcast messages only has one type now "error notification", but add TODO for more types, which may display in different ways (via toast, etc)
-    - Maybe only streaming? We'll miss some, but... not that much...
-    - ALSO owns the discord messaging code
-    - Suppression... will work in the service itself. Because there shouldn't be THAT many errors happening!
-    - Suppression will use AI to group?
-    - BUT, we will still have page that shows suppression list, with counts and times
-        - Page links to search, which tries to find those errors (we should use the same format for suppression as search, so it should be fairly easy to do that)
 
 
 

package/src/diagnostics/managementPages.tsx

@@ -275,6 +275,8 @@ export function renderIsManagementUser() {
     return isManagementUserValue().value;
 }
 
+const ErrorWarning = createLazyComponent(() => import("./logs/errorNotifications2/ErrorWarning"))("ErrorWarning");
+
 class ManagementRoot extends qreact.Component {
     state = {
         ready: false
@@ -319,6 +321,7 @@ class ManagementRoot extends qreact.Component {
                         .color("white")
                         .color("hsl(0, 0%, 7%)")
                         .pointerEvents("none")
+                    + " ManagementRoot-page"
                 }>
                     <style>
                         {`
@@ -327,7 +330,8 @@ class ManagementRoot extends qreact.Component {
                             }
                         `}
                     </style>
-                    <div class={css.fillWidth.hbox(30, 10).wrap.hsl(245, 25, 60).pad2(10).pointerEvents("all")}>
+                    <div class={css.fillWidth.hbox(30, 10).wrap.hsl(245, 25, 80).pad2(10).pointerEvents("all")}>
+                        <ErrorWarning />
                         {pages.map(page =>
                             <ATag values={[{ param: managementPageURL, value: page.componentName }]}>{page.title}</ATag>
                         )}
@@ -337,7 +341,7 @@ class ManagementRoot extends qreact.Component {
                             class={
                                 css.fillBoth.vbox0.overflowAuto.hsl(145, 50, 75)
                                     .pointerEvents("all")
-                                + " ManagementRoot-page"
+
                             }
                             onKeyDown={e => {
                                 if (e.currentTarget === e.target) {

package/src/user-implementation/SecurityPage.tsx

@@ -59,6 +59,12 @@ class ConfigTab extends qreact.Component {
                     value={user_data().secure.notifyDiscordWebhookURL}
                     onChangeValue={value => user_functions.setNotifyDiscordWebhookURL({ webhookURL: value })}
                 />
+                <InputLabel
+                    label={"OpenRouter API Key"}
+                    edit
+                    value={user_data().secure.openRouterAPIKey}
+                    onChangeValue={value => user_functions.setOpenRouterAPIKey({ apiKey: value })}
+                />
                 <Button onClick={() => user_functions.testSendDiscordMessage()}>
                     Test Discord Message
                 </Button>

package/src/user-implementation/userData.ts

@@ -13,7 +13,7 @@ import { MAX_ACCEPTED_CHANGE_AGE } from "../0-path-value-core/pathValueCore";
 import { createURLSync } from "../library-components/URLParam";
 import { devDebugbreak, getDomain, getEmailDomain, isDevDebugbreak, isRecovery } from "../config";
 import { delay } from "socket-function/src/batching";
-import { enableErrorNotifications } from "../library-components/errorNotifications";
+import { enableErrorNotifications } from "../library-components/uncaughtToast";
 import { clamp } from "../misc";
 import { sha256 } from "js-sha256";
 import { logDisk } from "../diagnostics/logs/diskLogger";
@@ -166,6 +166,7 @@ const { data, functions } = Querysub.syncSchema<{
         signupsOpen?: boolean;
         postmarkAPIKey?: string;
         notifyDiscordWebhookURL?: string;
+        openRouterAPIKey?: string;
 
         // NOTE: For now these will only be blocked at a user level. If we run into issues, we can
         //  make Querysub have configurable IP blocking that accepts a synced read function, which
@@ -223,6 +224,7 @@ const { data, functions } = Querysub.syncSchema<{
         specialSetInviteCount,
         setPostmarkAPIKey,
         setNotifyDiscordWebhookURL,
+        setOpenRouterAPIKey,
         specialSetUserType,
         registerPageLoadTime,
         banUser, unbanUser,
@@ -978,6 +980,9 @@ function setPostmarkAPIKey(config: { apiKey: string; }) {
 function setNotifyDiscordWebhookURL(config: { webhookURL: string; }) {
     data().secure.notifyDiscordWebhookURL = config.webhookURL;
 }
+function setOpenRouterAPIKey(config: { apiKey: string; }) {
+    data().secure.openRouterAPIKey = config.apiKey;
+}
 
 
 function banUser(config: { userId: string; }) {