@prbe.ai/electron-sdk 0.1.0

package/dist/agent.js

@@ -0,0 +1,861 @@
+"use strict";
+/**
+ * agent.ts — PRBEAgent class
+ *
+ * Main entry point for the PRBE debug agent SDK.
+ * Handles WebSocket connection to middleware, investigation lifecycle,
+ * background polling for context requests, file uploads, and persistence.
+ *
+ * Mirrors PRBEAgent.swift behavior.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRBEAgent = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto_1 = require("crypto");
+const models_1 = require("./models");
+const models_2 = require("./models");
+const state_1 = require("./state");
+const index_1 = require("./tools/index");
+const filesystem_1 = require("./tools/filesystem");
+const logs_1 = require("./tools/logs");
+const interactive_1 = require("./tools/interactive");
+const bash_1 = require("./tools/bash");
+const interactions_1 = require("./interactions");
+function getPersistencePath() {
+    // Use platform-appropriate app data directory
+    const appData = process.env["APPDATA"] ||
+        (process.platform === "darwin"
+            ? path.join(os.homedir(), "Library", "Application Support")
+            : path.join(os.homedir(), ".local", "share"));
+    const dir = path.join(appData, "prbe-agent");
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    return path.join(dir, "agent-state.json");
+}
+function loadPersistedData() {
+    try {
+        const filePath = getPersistencePath();
+        if (fs.existsSync(filePath)) {
+            const raw = fs.readFileSync(filePath, "utf-8");
+            return JSON.parse(raw);
+        }
+    }
+    catch {
+        // Ignore read errors, return defaults
+    }
+    return {};
+}
+function savePersistedData(data) {
+    try {
+        const filePath = getPersistencePath();
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+    }
+    catch {
+        console.error("[PRBEAgent] Failed to save persisted data");
+    }
+}
+// ---------------------------------------------------------------------------
+// PRBEAgent
+// ---------------------------------------------------------------------------
+class PRBEAgent {
+    state;
+    logCapture;
+    config;
+    interactionHandler;
+    registry = new index_1.PRBEToolRegistry();
+    grantedPaths = new Set();
+    userCancelled = false;
+    activeWS = null;
+    pollingTimer = null;
+    persistedData;
+    fetchAbortController = null;
+    currentInvestigationSource = interactions_1.InvestigationSource.USER;
+    currentCRId = null;
+    /** Files flagged during the current tool call — uploaded immediately after the tool returns. */
+    pendingFlaggedFiles = [];
+    // ---------- Persistence ----------
+    get agentID() {
+        if (this.persistedData.agentId) {
+            return this.persistedData.agentId;
+        }
+        const newID = (0, crypto_1.randomUUID)();
+        this.persistedData.agentId = newID;
+        savePersistedData(this.persistedData);
+        return newID;
+    }
+    get trackedTicketIDs() {
+        return this.persistedData.ticketIds ?? [];
+    }
+    set trackedTicketIDs(ids) {
+        this.persistedData.ticketIds = ids;
+        savePersistedData(this.persistedData);
+        this.state.updateTrackedTicketIDs(ids);
+        this.syncPolling(ids.length > 0);
+    }
+    get respondedCRIDs() {
+        return new Set(this.persistedData.respondedCRIds ?? []);
+    }
+    set respondedCRIDs(ids) {
+        this.persistedData.respondedCRIds = Array.from(ids);
+        savePersistedData(this.persistedData);
+    }
+    syncPolling(hasTickets) {
+        if (this.config.backgroundPolling && hasTickets) {
+            if (this.pollingTimer === null) {
+                this.startPolling();
+            }
+        }
+        else if (!hasTickets) {
+            this.stopPolling();
+        }
+    }
+    addTrackedTicket(id) {
+        const ids = this.trackedTicketIDs;
+        if (!ids.includes(id)) {
+            this.trackedTicketIDs = [...ids, id];
+        }
+    }
+    // ---------- Constructor ----------
+    constructor(config) {
+        this.config = {
+            apiKey: config.apiKey,
+            allowedRoots: config.allowedRoots,
+            pollingInterval: config.pollingInterval ?? 600_000,
+            maxLogEntries: config.maxLogEntries ?? 10_000,
+            captureConsole: config.captureConsole ?? true,
+            backgroundPolling: config.backgroundPolling ?? true,
+        };
+        this.interactionHandler = config.interactionHandler;
+        this.state = new state_1.PRBEAgentState();
+        this.logCapture = new logs_1.PRBELogCapture(this.config.maxLogEntries);
+        this.persistedData = loadPersistedData();
+        const roots = this.config.allowedRoots;
+        const requester = this.interactionHandler ? this : undefined;
+        const grantedPaths = this.grantedPaths;
+        // Register built-in filesystem tools
+        this.registry.register(new filesystem_1.ListDirectoryTool(roots, requester, grantedPaths));
+        this.registry.register(new filesystem_1.ReadFileTool(roots, requester, grantedPaths));
+        this.registry.register(new filesystem_1.SearchContentTool(roots, requester, grantedPaths));
+        this.registry.register(new filesystem_1.FindFilesTool(roots, requester, grantedPaths));
+        this.registry.register(new filesystem_1.FlagFileTool(roots, (file) => {
+            this.pendingFlaggedFiles.push(file);
+        }, requester, grantedPaths));
+        // Register built-in log tools
+        this.registry.register(new logs_1.ReadAppLogsTool(this.logCapture));
+        this.registry.register(new logs_1.SearchAppLogsTool(this.logCapture));
+        this.registry.register(new logs_1.ClearAppLogsTool(this.logCapture));
+        this.registry.register(new logs_1.FlagAppLogsTool(this.logCapture, (file) => {
+            this.pendingFlaggedFiles.push(file);
+        }));
+        // Register interactive tools (only when handler is available)
+        if (requester) {
+            this.registry.register(new interactive_1.AskUserTool(requester));
+            this.registry.register(new bash_1.BashExecuteTool(requester, roots, grantedPaths));
+        }
+        // Start console capture if configured
+        if (this.config.captureConsole) {
+            this.logCapture.startCapturing();
+        }
+        // Hook electron-log if provided
+        if (config.electronLog) {
+            this.hookElectronLog(config.electronLog);
+        }
+        // Listen for renderer log forwarding via IPC if provided
+        if (config.ipcMain) {
+            this.hookRendererLogs(config.ipcMain, config.rendererLogChannel ?? "prbe-renderer-log");
+        }
+        // Bootstrap: trigger syncPolling + state update for existing tickets
+        const existingTickets = this.trackedTicketIDs;
+        if (existingTickets.length > 0) {
+            this.trackedTicketIDs = existingTickets;
+        }
+    }
+    // ---------- Log integration ----------
+    hookElectronLog(electronLog) {
+        try {
+            electronLog.hooks.push((message, _transportFn, transportName) => {
+                if (transportName !== "file")
+                    return message;
+                try {
+                    const text = message.data
+                        .map((d) => (typeof d === "string" ? d : JSON.stringify(d)))
+                        .join(" ");
+                    const level = PRBEAgent.mapElectronLogLevel(message.level);
+                    this.logCapture.log(text, level, `electron-log.${message.level}`);
+                }
+                catch {
+                    // ignore serialization errors
+                }
+                return message;
+            });
+        }
+        catch {
+            // electron-log not available or incompatible
+        }
+    }
+    hookRendererLogs(ipcMain, channel) {
+        ipcMain.on(channel, (_event, entry) => {
+            this.logCapture.log(entry.message, entry.level, `renderer.${entry.category}`);
+        });
+    }
+    static mapElectronLogLevel(level) {
+        switch (level) {
+            case "error": return "ERROR";
+            case "warn": return "WARNING";
+            case "debug":
+            case "verbose":
+            case "silly": return "DEBUG";
+            default: return "INFO";
+        }
+    }
+    // ---------- PRBEInteractionRequester implementation ----------
+    get investigationSource() {
+        return this.currentInvestigationSource;
+    }
+    async requestUserInteraction(payload) {
+        if (!this.interactionHandler) {
+            throw new models_2.PRBEAgentError(models_2.PRBEAgentErrorType.SERVER_ERROR, "No interaction handler configured");
+        }
+        // Update state to show pending interaction
+        if (this.currentInvestigationSource === interactions_1.InvestigationSource.CONTEXT_REQUEST && this.currentCRId) {
+            this.state.setCRPendingInteraction(this.currentCRId, payload);
+        }
+        else {
+            this.state.setPendingInteraction(payload);
+        }
+        try {
+            const response = await this.interactionHandler.handleInteraction(payload);
+            return response;
+        }
+        finally {
+            if (this.currentInvestigationSource === interactions_1.InvestigationSource.CONTEXT_REQUEST && this.currentCRId) {
+                this.state.clearCRPendingInteraction(this.currentCRId);
+            }
+            else {
+                this.state.clearPendingInteraction();
+            }
+        }
+    }
+    /**
+     * Add an additional root directory to the runtime allowed roots.
+     */
+    addAllowedRoot(rootPath) {
+        if (!this.config.allowedRoots.includes(rootPath)) {
+            this.config.allowedRoots.push(rootPath);
+        }
+    }
+    // ---------- Public API ----------
+    /**
+     * Register a custom tool that the middleware can invoke during investigations.
+     */
+    registerTool(name, description, parameters, handler) {
+        this.registry.register(new index_1.PRBEClosureTool(name, description, parameters, handler));
+    }
+    /**
+     * User-initiated investigation. Updates `state` events/report directly.
+     */
+    async investigate(query, contextRequestID) {
+        this.userCancelled = false;
+        this.currentInvestigationSource = interactions_1.InvestigationSource.USER;
+        this.currentCRId = null;
+        this.state.beginInvestigation(query);
+        const emitter = (status) => {
+            // Update state based on status
+            switch (status.type) {
+                case models_2.PRBEAgentStatusType.STARTED:
+                    this.state.appendEvent("Starting investigation...");
+                    break;
+                case models_2.PRBEAgentStatusType.THINKING:
+                    break;
+                case models_2.PRBEAgentStatusType.TOOL_CALL:
+                    this.state.appendEvent(status.label);
+                    break;
+                case models_2.PRBEAgentStatusType.OBSERVATION:
+                    this.state.attachObservation(status.text);
+                    break;
+                case models_2.PRBEAgentStatusType.THOUGHT:
+                    this.state.appendEvent("Thinking", status.text);
+                    break;
+                case models_2.PRBEAgentStatusType.COMPLETED:
+                    this.state.completeInvestigation(status.report, status.userSummary);
+                    break;
+                case models_2.PRBEAgentStatusType.ERROR:
+                    this.state.failInvestigation(status.message);
+                    break;
+            }
+        };
+        const result = await this.connectToProxy(query, contextRequestID, emitter, () => this.userCancelled);
+        this.currentInvestigationSource = interactions_1.InvestigationSource.USER;
+        this.currentCRId = null;
+        if (result?.ticketId) {
+            this.addTrackedTicket(result.ticketId);
+        }
+        else if (!result) {
+            // No result — either cancelled or errored
+            if (this.state.isInvestigating) {
+                const message = this.userCancelled
+                    ? "Investigation cancelled"
+                    : "Investigation ended unexpectedly";
+                this.state.failInvestigation(message);
+            }
+        }
+    }
+    /**
+     * Cancel user-initiated investigation only (does not cancel background CRs).
+     */
+    cancelInvestigation() {
+        this.userCancelled = true;
+        if (this.activeWS) {
+            this.activeWS.close(1000, "User cancelled");
+            this.activeWS = null;
+        }
+    }
+    /**
+     * Cancel everything — user investigation and polling.
+     */
+    cancel() {
+        this.userCancelled = true;
+        if (this.activeWS) {
+            this.activeWS.close(1000, "User cancelled");
+            this.activeWS = null;
+        }
+        this.abortInFlightRequests();
+        this.stopPolling();
+    }
+    /**
+     * Poll the backend for context requests on tracked tickets.
+     */
+    async poll() {
+        const ticketIDs = this.trackedTicketIDs;
+        if (ticketIDs.length === 0)
+            return null;
+        const request = {
+            agent_id: this.agentID,
+            ticket_ids: ticketIDs,
+        };
+        try {
+            const response = await this.post("/api/agent/poll", request);
+            // Discard ticket IDs the backend didn't return (deleted/unknown)
+            const returnedIDs = new Set(response.tickets.map((t) => t.ticket_id));
+            const orphaned = ticketIDs.filter((id) => !returnedIDs.has(id));
+            if (orphaned.length > 0) {
+                this.trackedTicketIDs = this.trackedTicketIDs.filter((id) => !orphaned.includes(id));
+            }
+            // Collect all CR IDs the backend knows about for pruning
+            const knownCRIDs = new Set();
+            for (const ticket of response.tickets) {
+                if (ticket.status === "resolved") {
+                    this.trackedTicketIDs = this.trackedTicketIDs.filter((id) => id !== ticket.ticket_id);
+                }
+                for (const cr of ticket.context_requests) {
+                    knownCRIDs.add(cr.id);
+                    // Skip inactive or already-responded CRs
+                    if (!cr.is_active || this.respondedCRIDs.has(cr.id))
+                        continue;
+                    await this.investigateForCR(cr, ticket.ticket_id);
+                    const ids = this.respondedCRIDs;
+                    ids.add(cr.id);
+                    this.respondedCRIDs = ids;
+                }
+            }
+            // Prune responded CR IDs for CRs the backend no longer returns
+            const currentRespondedIDs = this.respondedCRIDs;
+            const stale = new Set([...currentRespondedIDs].filter((id) => !knownCRIDs.has(id)));
+            if (stale.size > 0) {
+                const pruned = new Set([...currentRespondedIDs].filter((id) => !stale.has(id)));
+                this.respondedCRIDs = pruned;
+            }
+            return response;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Fetch ticket display info for all tracked tickets.
+     */
+    async fetchTicketInfo() {
+        const ticketIDs = this.trackedTicketIDs;
+        if (ticketIDs.length === 0)
+            return [];
+        const request = { ticket_ids: ticketIDs };
+        try {
+            const response = await this.post("/api/agent/tickets", request);
+            this.state.updateTicketInfo(response.tickets);
+            return response.tickets;
+        }
+        catch {
+            return [];
+        }
+    }
+    stopPolling() {
+        if (this.pollingTimer !== null) {
+            clearInterval(this.pollingTimer);
+            this.pollingTimer = null;
+        }
+    }
+    resumePolling() {
+        if (this.trackedTicketIDs.length === 0)
+            return;
+        this.startPolling();
+    }
+    /**
+     * Destroy the agent — stops polling, stops console capture, closes WS.
+     */
+    destroy() {
+        this.cancel();
+        this.logCapture.stopCapturing();
+    }
+    /**
+     * Reset all persisted data (agent ID, tracked tickets, responded CRs).
+     * Also clears in-memory state.
+     */
+    resetPersistedData() {
+        this.stopPolling();
+        this.persistedData = {};
+        savePersistedData(this.persistedData);
+        this.state.resetInvestigation();
+        this.state.completedInvestigations = [];
+        this.state.activeCRs.clear();
+        this.state.completedCRs = [];
+        this.state.trackedTicketIDs = [];
+        this.state.ticketInfo = [];
+        this.state.emit(state_1.PRBEStateEvent.STATUS);
+    }
+    /**
+     * Delete the persisted data file. Can be called without an agent instance.
+     */
+    static clearPersistedData() {
+        try {
+            const filePath = getPersistencePath();
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+            }
+        }
+        catch {
+            // Ignore
+        }
+    }
+    // ---------- CR Investigation ----------
+    async investigateForCR(cr, ticketId) {
+        const crID = cr.id;
+        this.currentInvestigationSource = interactions_1.InvestigationSource.CONTEXT_REQUEST;
+        this.currentCRId = crID;
+        this.state.beginCR(crID, cr.query, cr.slug ?? undefined);
+        const emitter = (status) => {
+            switch (status.type) {
+                case models_2.PRBEAgentStatusType.STARTED:
+                    this.state.appendCREvent(crID, "Starting investigation...");
+                    break;
+                case models_2.PRBEAgentStatusType.THINKING:
+                    break;
+                case models_2.PRBEAgentStatusType.TOOL_CALL:
+                    this.state.appendCREvent(crID, status.label);
+                    break;
+                case models_2.PRBEAgentStatusType.OBSERVATION:
+                    this.state.attachCRObservation(crID, status.text);
+                    break;
+                case models_2.PRBEAgentStatusType.THOUGHT:
+                    this.state.appendCREvent(crID, "Thinking", status.text);
+                    break;
+                case models_2.PRBEAgentStatusType.COMPLETED:
+                    this.state.completeCR(crID, status.report, status.userSummary);
+                    break;
+                case models_2.PRBEAgentStatusType.ERROR:
+                    this.state.failCR(crID, status.message);
+                    break;
+            }
+        };
+        const result = await this.connectToProxy(cr.query, crID, emitter, () => false, // CRs are not user-cancellable
+        ticketId);
+        this.currentInvestigationSource = interactions_1.InvestigationSource.USER;
+        this.currentCRId = null;
+        if (result?.ticketId) {
+            this.addTrackedTicket(result.ticketId);
+        }
+    }
+    // ---------- WebSocket Investigation ----------
+    connectToProxy(query, contextRequestID, emit, isCancelled, ticketId) {
+        return new Promise((resolve) => {
+            const wsUrl = `${models_1.MIDDLEWARE_URL}/api/agent/client/ws`;
+            let ws;
+            try {
+                ws = new WebSocket(wsUrl, {
+                    headers: {
+                        "X-API-Key": this.config.apiKey,
+                    },
+                });
+            }
+            catch (err) {
+                emit({
+                    type: models_2.PRBEAgentStatusType.ERROR,
+                    message: `Failed to create WebSocket: ${err}`,
+                });
+                resolve(null);
+                return;
+            }
+            this.activeWS = ws;
+            let uploadBaseUrl;
+            let resolved = false;
+            const finish = (result) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                this.activeWS = null;
+                resolve(result);
+            };
+            ws.onopen = () => {
+                // Build tool declarations for the start message
+                const toolDeclarations = this.registry
+                    .allDeclarations()
+                    .map((decl) => ({
+                    name: decl.name,
+                    description: decl.description,
+                    parameters: decl.parameters.map((param) => ({
+                        name: param.name,
+                        type: param.type,
+                        description: param.description,
+                        required: param.required,
+                    })),
+                }));
+                const startMetadata = {
+                    agent_id: this.agentID,
+                    custom_tools: toolDeclarations,
+                };
+                if (contextRequestID) {
+                    startMetadata["context_request_id"] = contextRequestID;
+                }
+                if (ticketId) {
+                    startMetadata["ticket_id"] = ticketId;
+                }
+                const startMsg = {
+                    type: models_1.WSMessageType.START,
+                    content: query,
+                    metadata: startMetadata,
+                };
+                try {
+                    ws.send(JSON.stringify(startMsg));
+                }
+                catch (err) {
+                    emit({
+                        type: models_2.PRBEAgentStatusType.ERROR,
+                        message: `Failed to send start message: ${err}`,
+                    });
+                    finish(null);
+                    return;
+                }
+                emit({ type: models_2.PRBEAgentStatusType.STARTED });
+                this.pendingFlaggedFiles = [];
+            };
+            ws.onmessage = async (event) => {
+                if (isCancelled()) {
+                    this.sendCancel(ws);
+                    ws.close(1000, "Cancelled");
+                    finish(null);
+                    return;
+                }
+                let raw;
+                if (typeof event.data === "string") {
+                    raw = event.data;
+                }
+                else if (event.data instanceof Buffer) {
+                    raw = event.data.toString("utf-8");
+                }
+                else {
+                    return;
+                }
+                let msg;
+                try {
+                    msg = JSON.parse(raw);
+                }
+                catch {
+                    return;
+                }
+                switch (msg.type) {
+                    case models_1.WSMessageType.THOUGHT:
+                        emit({
+                            type: models_2.PRBEAgentStatusType.THOUGHT,
+                            text: msg.content ?? "",
+                        });
+                        break;
+                    case models_1.WSMessageType.TOOL_CALL: {
+                        const toolName = msg.name ?? "";
+                        const callId = msg.id ?? "";
+                        const args = this.extractArgs(msg.metadata);
+                        emit({
+                            type: models_2.PRBEAgentStatusType.TOOL_CALL,
+                            name: toolName,
+                            label: msg.content ?? `Running ${toolName}`,
+                        });
+                        // Clear before execution so we only capture files flagged by this tool call
+                        this.pendingFlaggedFiles = [];
+                        const toolResult = (0, models_1.redactPII)(await this.registry.execute(toolName, args));
+                        emit({
+                            type: models_2.PRBEAgentStatusType.OBSERVATION,
+                            text: toolResult.substring(0, 200),
+                        });
+                        // Build refs for any files flagged during this tool call
+                        let resultMetadata;
+                        if (this.pendingFlaggedFiles.length > 0 && uploadBaseUrl) {
+                            const uploadPrefix = this.extractUploadPrefix(uploadBaseUrl);
+                            const uploadedRefs = [];
+                            for (const file of this.pendingFlaggedFiles) {
+                                const filename = path.basename(file.originalPath);
+                                const safeName = encodeURIComponent(filename);
+                                const storagePath = `${uploadPrefix}/${safeName}`;
+                                uploadedRefs.push({
+                                    original_path: file.originalPath,
+                                    reason: file.reason ?? "",
+                                    storage_path: storagePath,
+                                    file_size_bytes: file.data.length,
+                                });
+                                // Background upload — don't block the tool_result
+                                const uploadUrl = `${uploadBaseUrl}/${safeName}`;
+                                const fileData = file.data;
+                                const contentType = file.isText
+                                    ? "text/plain"
+                                    : "application/octet-stream";
+                                void PRBEAgent.backgroundUpload(fileData, uploadUrl, this.config.apiKey, contentType, this.getFetchSignal());
+                            }
+                            resultMetadata = { flagged_files: uploadedRefs };
+                            this.pendingFlaggedFiles = [];
+                        }
+                        const resultMsg = {
+                            type: models_1.WSMessageType.TOOL_RESULT,
+                            id: callId,
+                            name: toolName,
+                            content: toolResult,
+                            metadata: resultMetadata,
+                        };
+                        try {
+                            ws.send(JSON.stringify(resultMsg));
+                        }
+                        catch {
+                            // Send failed — will be caught by onerror/onclose
+                        }
+                        break;
+                    }
+                    case models_1.WSMessageType.SERVER_TOOL_CALL:
+                        emit({
+                            type: models_2.PRBEAgentStatusType.TOOL_CALL,
+                            name: msg.name ?? "",
+                            label: msg.content ?? "",
+                        });
+                        break;
+                    case models_1.WSMessageType.SERVER_OBSERVATION:
+                        emit({
+                            type: models_2.PRBEAgentStatusType.OBSERVATION,
+                            text: (msg.content ?? "").substring(0, 200),
+                        });
+                        break;
+                    case models_1.WSMessageType.COMPLETE: {
+                        const report = msg.content ?? "";
+                        const userSummary = msg.metadata?.["user_summary"] ?? "";
+                        const ticketId = msg.metadata?.["ticket_id"];
+                        emit({
+                            type: models_2.PRBEAgentStatusType.COMPLETED,
+                            report,
+                            userSummary,
+                        });
+                        ws.close(1000, "Complete");
+                        finish({ report, userSummary, ticketId });
+                        break;
+                    }
+                    case models_1.WSMessageType.ERROR:
+                        emit({
+                            type: models_2.PRBEAgentStatusType.ERROR,
+                            message: msg.content || "Unknown error",
+                        });
+                        ws.close(1000, "Error received");
+                        finish(null);
+                        break;
+                    case models_1.WSMessageType.SESSION_CONFIG:
+                        uploadBaseUrl = msg.metadata?.["upload_url"];
+                        break;
+                    case models_1.WSMessageType.PING: {
+                        const pongMsg = { type: models_1.WSMessageType.PONG };
+                        try {
+                            ws.send(JSON.stringify(pongMsg));
+                        }
+                        catch {
+                            // Ignore pong send failures
+                        }
+                        break;
+                    }
+                    // SDK-originated types and upload_url — ignore
+                    case models_1.WSMessageType.START:
+                    case models_1.WSMessageType.TOOL_RESULT:
+                    case models_1.WSMessageType.UPLOAD_REQUEST:
+                    case models_1.WSMessageType.CANCEL:
+                    case models_1.WSMessageType.PONG:
+                    case models_1.WSMessageType.UPLOAD_URL:
+                        break;
+                }
+            };
+            ws.onerror = (event) => {
+                if (isCancelled()) {
+                    finish(null);
+                    return;
+                }
+                const errorEvent = event;
+                const message = errorEvent.message || "WebSocket connection error";
+                emit({ type: models_2.PRBEAgentStatusType.ERROR, message });
+                finish(null);
+            };
+            ws.onclose = (_event) => {
+                // If we haven't resolved yet, treat as unexpected close
+                if (!resolved) {
+                    if (isCancelled()) {
+                        finish(null);
+                    }
+                    else {
+                        emit({
+                            type: models_2.PRBEAgentStatusType.ERROR,
+                            message: "WebSocket connection closed unexpectedly",
+                        });
+                        finish(null);
+                    }
+                }
+            };
+        });
+    }
+    sendCancel(ws) {
+        try {
+            const cancelMsg = { type: models_1.WSMessageType.CANCEL };
+            ws.send(JSON.stringify(cancelMsg));
+        }
+        catch {
+            // Ignore
+        }
+    }
+    extractArgs(metadata) {
+        if (!metadata)
+            return {};
+        const argsVal = metadata["args"];
+        if (argsVal && typeof argsVal === "object" && !Array.isArray(argsVal)) {
+            return argsVal;
+        }
+        return {};
+    }
+    extractUploadPrefix(baseUrl) {
+        try {
+            const url = new URL(baseUrl);
+            const urlPath = url.pathname; // "/api/agent/upload/{tenant}/{uuid}/files"
+            const marker = "/api/agent/upload/";
+            const idx = urlPath.indexOf(marker);
+            if (idx !== -1) {
+                return urlPath.substring(idx + marker.length);
+            }
+        }
+        catch {
+            // Ignore URL parse errors
+        }
+        return "";
+    }
+    // ---------- File Upload ----------
+    static async backgroundUpload(data, uploadUrl, apiKey, contentType, signal) {
+        try {
+            const response = await fetch(uploadUrl, {
+                method: "PUT",
+                headers: {
+                    "Content-Type": contentType,
+                    "X-API-Key": apiKey,
+                },
+                body: data,
+                signal,
+            });
+            if (!response.ok) {
+                console.error(`[PRBEAgent] file upload failed: HTTP ${response.status} for ${uploadUrl}`);
+            }
+        }
+        catch (err) {
+            console.error(`[PRBEAgent] file upload error: ${err} for ${uploadUrl}`);
+        }
+    }
+    // ---------- Polling ----------
+    startPolling() {
+        this.stopPolling();
+        this.pollingTimer = setInterval(() => {
+            void this.poll().then(() => {
+                if (this.trackedTicketIDs.length === 0) {
+                    this.stopPolling();
+                }
+            });
+        }, this.config.pollingInterval);
+    }
+    // ---------- Networking ----------
+    /**
+     * Abort all in-flight fetch requests to prevent orphaned DNS lookups
+     * that can crash the c-ares resolver during process shutdown.
+     */
+    abortInFlightRequests() {
+        if (this.fetchAbortController) {
+            this.fetchAbortController.abort();
+            this.fetchAbortController = null;
+        }
+    }
+    /**
+     * Get an AbortSignal for fetch requests. Creates a new controller if needed.
+     */
+    getFetchSignal() {
+        if (!this.fetchAbortController) {
+            this.fetchAbortController = new AbortController();
+        }
+        return this.fetchAbortController.signal;
+    }
+    async post(urlPath, body) {
+        const url = `${models_1.API_URL}${urlPath}`;
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-API-Key": this.config.apiKey,
+            },
+            body: JSON.stringify(body),
+            signal: this.getFetchSignal(),
+        });
+        if (!response.ok) {
+            const message = await response.text().catch(() => "Unknown error");
+            throw new models_2.PRBEAgentError(models_2.PRBEAgentErrorType.SERVER_ERROR, `Server error ${response.status}: ${message}`, response.status);
+        }
+        return (await response.json());
+    }
+}
+exports.PRBEAgent = PRBEAgent;
+//# sourceMappingURL=agent.js.map