querysub 0.497.0 → 0.499.0

package/src/diagnostics/logs/errorTickets/autoFixerEntry.ts

@@ -0,0 +1,24 @@
+module.hotreload = false;
+
+// Allow callers to point this process at a different querysub project root (so we use the right keys/certs/local data) before any other imports run.
+{
+    let argv = process.argv;
+    let cwdIdx = argv.indexOf("--cwd");
+    if (cwdIdx >= 0 && argv[cwdIdx + 1]) {
+        process.chdir(argv[cwdIdx + 1]);
+        argv.splice(cwdIdx, 2);
+    }
+}
+
+import "../../../inject";
+
+import { logErrors } from "../../../errors";
+import { Querysub } from "../../../4-querysub/Querysub";
+import { runAutoFixer } from "./autoFixer";
+
+logErrors(main());
+
+async function main() {
+    await Querysub.hostService("AutoFixer");
+    await runAutoFixer();
+}

package/src/diagnostics/logs/errorTickets/ticketTypes.ts

@@ -0,0 +1,47 @@
+import { LogDatum } from "../diskLogger";
+
+export type TicketState = "investigation" | "code-change" | "fixed" | "not-a-bug" | "timed-out";
+export const TICKET_STATES: TicketState[] = ["investigation", "code-change", "fixed", "not-a-bug", "timed-out"];
+
+export type TicketPatchStatus = "pending" | "applied" | "rejected";
+
+export type TicketPatchFile = {
+    file: string;
+    // Empty oldText means "create the file with newText" (or fully overwrite an empty file).
+    oldText: string;
+    newText: string;
+};
+
+export type TicketCommentKind = "text" | "patch" | "tool-call";
+
+export type TicketComment = {
+    id: string;
+    time: number;
+    author: string;
+    kind: TicketCommentKind;
+    text: string;
+
+    patchFiles?: TicketPatchFile[];
+    patchStatus?: TicketPatchStatus;
+    patchStatusTime?: number;
+
+    toolName?: string;
+    toolInput?: string;
+    toolOutput?: string;
+    toolDurationMs?: number;
+};
+
+export type Ticket = {
+    id: string;
+    title: string;
+    state: TicketState;
+    createdTime: number;
+    lastUpdatedTime: number;
+
+    // The full log datum the ticket was created from, so every field in the log is preserved in the ticket.
+    errorDatum: LogDatum;
+    // The suppression pattern that matched the error, when the ticket was created from a suppression entry.
+    suppressionPattern?: string;
+
+    comments: TicketComment[];
+};

package/src/diagnostics/logs/errorTickets/tickets.ts

@@ -0,0 +1,264 @@
+import { lazy } from "socket-function/src/caching";
+import { batchFunction, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { timeInMinute } from "socket-function/src/misc";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { nestArchives } from "../../../-a-archives/archives";
+import { getArchivesBackblaze } from "../../../-a-archives/archivesBackBlaze";
+import { archiveJSONT } from "../../../-a-archives/archivesJSONT";
+import { getDomain, isPublic } from "../../../config";
+import { getControllerNodeId } from "../../../-g-core-values/NodeCapabilities";
+import { assertIsManagementUser } from "../../managementPages";
+import { getSyncedController } from "../../../library-components/SyncedController";
+import { AutoFixerControllerBase } from "./autoFixerController";
+import { Ticket, TicketComment, TicketPatchStatus, TicketState } from "./ticketTypes";
+
+const TICKET_CACHE_POLL_INTERVAL = timeInMinute * 5;
+
+export const ticketsArchive = archiveJSONT<Ticket>(() => nestArchives("logs/error-tickets/", getArchivesBackblaze(getDomain())));
+
+let ticketCache = new Map<string, Ticket>();
+let ensureWatching = lazy(async () => {
+    await runInfinitePollCallAtStart(TICKET_CACHE_POLL_INTERVAL, async () => {
+        let tickets = await ticketsArchive.values();
+        ticketCache = new Map(tickets.map(ticket => [ticket.id, ticket]));
+    });
+});
+async function getTicketCache(): Promise<Map<string, Ticket>> {
+    await ensureWatching();
+    return ticketCache;
+}
+
+async function mutateTicket(id: string, mutate: (ticket: Ticket) => void): Promise<Ticket> {
+    let cache = await getTicketCache();
+    let ticket = cache.get(id);
+    if (!ticket) {
+        ticket = await ticketsArchive.get(id);
+        if (ticket) {
+            cache.set(id, ticket);
+        }
+    }
+    if (!ticket) {
+        throw new Error(`Ticket ${id} not found`);
+    }
+    let updated: Ticket = JSON.parse(JSON.stringify(ticket)) as Ticket;
+    mutate(updated);
+    updated.lastUpdatedTime = Date.now();
+    cache.set(id, updated);
+    await ticketsArchive.set(id, updated);
+    TicketService.triggerTicketsChanged(id);
+    return updated;
+}
+
+class TicketService {
+    public async getTickets(): Promise<Ticket[]> {
+        let cache = await getTicketCache();
+        return Array.from(cache.values());
+    }
+
+    public async getTicket(id: string): Promise<Ticket | undefined> {
+        let cache = await getTicketCache();
+        let ticket = cache.get(id);
+        if (ticket) return ticket;
+        ticket = await ticketsArchive.get(id);
+        if (ticket) {
+            cache.set(id, ticket);
+        }
+        return ticket;
+    }
+
+    public async createTicket(ticket: Ticket): Promise<void> {
+        let cache = await getTicketCache();
+        cache.set(ticket.id, ticket);
+        await ticketsArchive.set(ticket.id, ticket);
+        TicketService.triggerTicketsChanged(ticket.id);
+    }
+
+    public async deleteTicket(id: string): Promise<void> {
+        let cache = await getTicketCache();
+        cache.delete(id);
+        await ticketsArchive.delete(id);
+        TicketService.triggerTicketsChanged(id);
+    }
+
+    public async setTicketState(id: string, state: TicketState): Promise<void> {
+        await mutateTicket(id, ticket => {
+            ticket.state = state;
+        });
+    }
+
+    public async addComment(id: string, comment: TicketComment): Promise<void> {
+        await mutateTicket(id, ticket => {
+            ticket.comments.push(comment);
+        });
+    }
+
+    public async updateCommentText(id: string, commentId: string, text: string): Promise<void> {
+        await mutateTicket(id, ticket => {
+            let comment = ticket.comments.find(c => c.id === commentId);
+            if (!comment) {
+                throw new Error(`Comment ${commentId} not found in ticket ${id}`);
+            }
+            comment.text = text;
+        });
+    }
+
+    public async deleteComment(id: string, commentId: string): Promise<void> {
+        await mutateTicket(id, ticket => {
+            ticket.comments = ticket.comments.filter(c => c.id !== commentId);
+        });
+    }
+
+    public async setPatchStatus(id: string, commentId: string, status: TicketPatchStatus): Promise<void> {
+        await mutateTicket(id, ticket => {
+            let comment = ticket.comments.find(c => c.id === commentId);
+            if (!comment) {
+                throw new Error(`Comment ${commentId} not found in ticket ${id}`);
+            }
+            if (comment.kind !== "patch") {
+                throw new Error(`Comment ${commentId} is not a patch comment`);
+            }
+            comment.patchStatus = status;
+            comment.patchStatusTime = Date.now();
+        });
+    }
+
+    // Routes to a registered autofixer node, which does the filesystem work. On success we record the applied status.
+    public async applyPatch(id: string, commentId: string): Promise<void> {
+        let errors: string[] = [];
+        let applied = false;
+        for (let nodeId of Array.from(TicketService.autoFixerNodes)) {
+            try {
+                await AutoFixerControllerBase.nodes[nodeId].applyPatch(id, commentId);
+                applied = true;
+                break;
+            } catch (e) {
+                errors.push((e as Error).stack ?? String(e));
+            }
+        }
+        if (!applied) {
+            if (TicketService.autoFixerNodes.size === 0) {
+                throw new Error(`No autofixer is connected, so the patch cannot be applied. Run \`yarn autofixer\` in the repository the patch targets.`);
+            }
+            throw new Error(`Failed to apply patch on all connected autofixer nodes:\n${errors.join("\n")}`);
+        }
+        await this.setPatchStatus(id, commentId, "applied");
+    }
+
+    private static autoFixerNodes = new Set<string>();
+    public async registerAutoFixerSERVICE(): Promise<void> {
+        let caller = SocketFunction.getCaller();
+        TicketService.autoFixerNodes.add(caller.nodeId);
+    }
+
+    public static triggerTicketsChanged = batchFunction({ delay: 100 }, (ticketIds: string[]) => {
+        let uniqueIds = Array.from(new Set(ticketIds));
+        for (let nodeId of TicketService.autoFixerNodes) {
+            void (async () => {
+                try {
+                    await AutoFixerControllerBase.nodes[nodeId].onTicketsChanged(uniqueIds);
+                } catch {
+                    TicketService.autoFixerNodes.delete(nodeId);
+                }
+            })();
+        }
+    });
+}
+
+export const TicketServiceBase = SocketFunction.register(
+    "TicketService-019c9cae-8333-7708-a4e7-500f5fc23180",
+    new TicketService(),
+    () => ({
+        getTickets: {},
+        getTicket: {},
+        createTicket: {},
+        deleteTicket: {},
+        setTicketState: {},
+        addComment: {},
+        updateCommentText: {},
+        deleteComment: {},
+        setPatchStatus: {},
+        applyPatch: {},
+        registerAutoFixerSERVICE: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    }),
+    {
+        noAutoExpose: true,
+    }
+);
+
+export function exposeTicketService() {
+    SocketFunction.expose(TicketServiceBase);
+}
+
+async function getTicketServiceNode(): Promise<string> {
+    let controllerNodeId = await getControllerNodeId(TicketServiceBase, !isPublic());
+    if (!controllerNodeId) {
+        throw new Error(`Could not find node exposing controller TicketServiceBase. Is \`yarn error-watch\` running?`);
+    }
+    return controllerNodeId;
+}
+
+class TicketData {
+    public async getTickets(): Promise<Ticket[]> {
+        return await TicketServiceBase.nodes[await getTicketServiceNode()].getTickets();
+    }
+
+    public async getTicket(id: string): Promise<Ticket | undefined> {
+        return await TicketServiceBase.nodes[await getTicketServiceNode()].getTicket(id);
+    }
+
+    public async createTicket(ticket: Ticket): Promise<void> {
+        await TicketServiceBase.nodes[await getTicketServiceNode()].createTicket(ticket);
+    }
+
+    public async deleteTicket(id: string): Promise<void> {
+        await TicketServiceBase.nodes[await getTicketServiceNode()].deleteTicket(id);
+    }
+
+    public async setTicketState(id: string, state: TicketState): Promise<void> {
+        await TicketServiceBase.nodes[await getTicketServiceNode()].setTicketState(id, state);
+    }
+
+    public async addComment(id: string, comment: TicketComment): Promise<void> {
+        await TicketServiceBase.nodes[await getTicketServiceNode()].addComment(id, comment);
+    }
+
+    public async updateCommentText(id: string, commentId: string, text: string): Promise<void> {
+        await TicketServiceBase.nodes[await getTicketServiceNode()].updateCommentText(id, commentId, text);
+    }
+
+    public async deleteComment(id: string, commentId: string): Promise<void> {
+        await TicketServiceBase.nodes[await getTicketServiceNode()].deleteComment(id, commentId);
+    }
+
+    public async setPatchStatus(id: string, commentId: string, status: TicketPatchStatus): Promise<void> {
+        await TicketServiceBase.nodes[await getTicketServiceNode()].setPatchStatus(id, commentId, status);
+    }
+
+    public async applyPatch(id: string, commentId: string): Promise<void> {
+        await TicketServiceBase.nodes[await getTicketServiceNode()].applyPatch(id, commentId);
+    }
+}
+
+export const TicketDataBase = SocketFunction.register(
+    "TicketData-019c9cae-8333-7708-a4e7-500f5fc23181",
+    new TicketData(),
+    () => ({
+        getTickets: {},
+        getTicket: {},
+        createTicket: {},
+        deleteTicket: {},
+        setTicketState: {},
+        addComment: {},
+        updateCommentText: {},
+        deleteComment: {},
+        setPatchStatus: {},
+        applyPatch: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    })
+);
+export const TicketsController = getSyncedController(TicketDataBase);

package/src/diagnostics/managementPages.tsx

@@ -152,6 +152,12 @@ export async function registerManagementPages2(config: {
         controllerName: "",
         getModule: () => import("./logs/errorNotifications2/ErrorNotificationPage"),
     });
+    inputPages.push({
+        title: "Tickets",
+        componentName: "TicketPage",
+        controllerName: "",
+        getModule: () => import("./logs/errorTickets/TicketPage"),
+    });
     // NOTE: Even if we never use this, it is needed if a server or site is bootstrapping. However, they should probably include this in their own header dynamically as well. 
     inputPages.push({
         title: "Security",