@prbe.ai/electron-sdk 0.1.4 → 0.1.5

package/dist/index.mjs

@@ -0,0 +1,2402 @@
+// src/agent.ts
+import * as fs2 from "fs";
+import * as path4 from "path";
+import * as os from "os";
+import { randomUUID as randomUUID5 } from "crypto";
+
+// src/models.ts
+var WSMessageType = /* @__PURE__ */ ((WSMessageType2) => {
+  WSMessageType2["START"] = "start";
+  WSMessageType2["TOOL_RESULT"] = "tool_result";
+  WSMessageType2["UPLOAD_REQUEST"] = "upload_request";
+  WSMessageType2["CANCEL"] = "cancel";
+  WSMessageType2["PONG"] = "pong";
+  WSMessageType2["THOUGHT"] = "thought";
+  WSMessageType2["TOOL_CALL"] = "tool_call";
+  WSMessageType2["SERVER_TOOL_CALL"] = "server_tool_call";
+  WSMessageType2["SERVER_OBSERVATION"] = "server_observation";
+  WSMessageType2["UPLOAD_URL"] = "upload_url";
+  WSMessageType2["SESSION_CONFIG"] = "session_config";
+  WSMessageType2["COMPLETE"] = "complete";
+  WSMessageType2["ERROR"] = "error";
+  WSMessageType2["PING"] = "ping";
+  return WSMessageType2;
+})(WSMessageType || {});
+var ToolParamType = /* @__PURE__ */ ((ToolParamType2) => {
+  ToolParamType2["STRING"] = "STRING";
+  ToolParamType2["BOOLEAN"] = "BOOLEAN";
+  ToolParamType2["INTEGER"] = "INTEGER";
+  return ToolParamType2;
+})(ToolParamType || {});
+var ToolName = /* @__PURE__ */ ((ToolName2) => {
+  ToolName2["CLIENT_LIST_DIRECTORY"] = "client_list_directory";
+  ToolName2["CLIENT_READ_FILE"] = "client_read_file";
+  ToolName2["CLIENT_SEARCH_CONTENT"] = "client_search_content";
+  ToolName2["CLIENT_FIND_FILES"] = "client_find_files";
+  ToolName2["CLIENT_FLAG_FILE"] = "client_flag_file";
+  ToolName2["CLIENT_READ_APP_LOGS"] = "client_read_app_logs";
+  ToolName2["CLIENT_SEARCH_APP_LOGS"] = "client_search_app_logs";
+  ToolName2["CLIENT_CLEAR_APP_LOGS"] = "client_clear_app_logs";
+  ToolName2["CLIENT_FLAG_APP_LOGS"] = "client_flag_app_logs";
+  ToolName2["CLIENT_ASK_USER"] = "client_ask_user";
+  ToolName2["CLIENT_BASH_EXECUTE"] = "client_bash_execute";
+  return ToolName2;
+})(ToolName || {});
+var PRBEAgentConfigKey = /* @__PURE__ */ ((PRBEAgentConfigKey3) => {
+  PRBEAgentConfigKey3["API_KEY"] = "apiKey";
+  PRBEAgentConfigKey3["AUTO_APPROVED_DIRS"] = "autoApprovedDirs";
+  PRBEAgentConfigKey3["POLLING_INTERVAL"] = "pollingInterval";
+  PRBEAgentConfigKey3["MAX_LOG_ENTRIES"] = "maxLogEntries";
+  PRBEAgentConfigKey3["CAPTURE_CONSOLE"] = "captureConsole";
+  PRBEAgentConfigKey3["BACKGROUND_POLLING"] = "backgroundPolling";
+  PRBEAgentConfigKey3["INTERACTION_HANDLER"] = "interactionHandler";
+  PRBEAgentConfigKey3["ELECTRON_LOG"] = "electronLog";
+  PRBEAgentConfigKey3["IPC_MAIN"] = "ipcMain";
+  PRBEAgentConfigKey3["RENDERER_LOG_CHANNEL"] = "rendererLogChannel";
+  PRBEAgentConfigKey3["APP_DATA_PATH"] = "appDataPath";
+  return PRBEAgentConfigKey3;
+})(PRBEAgentConfigKey || {});
+var PRBEAgentStatusType = /* @__PURE__ */ ((PRBEAgentStatusType2) => {
+  PRBEAgentStatusType2["STARTED"] = "started";
+  PRBEAgentStatusType2["THINKING"] = "thinking";
+  PRBEAgentStatusType2["TOOL_CALL"] = "tool_call";
+  PRBEAgentStatusType2["THOUGHT"] = "thought";
+  PRBEAgentStatusType2["OBSERVATION"] = "observation";
+  PRBEAgentStatusType2["COMPLETED"] = "completed";
+  PRBEAgentStatusType2["ERROR"] = "error";
+  PRBEAgentStatusType2["AWAITING_INTERACTION"] = "awaiting_interaction";
+  return PRBEAgentStatusType2;
+})(PRBEAgentStatusType || {});
+var PRBEAgentErrorType = /* @__PURE__ */ ((PRBEAgentErrorType2) => {
+  PRBEAgentErrorType2["SERVER_ERROR"] = "server_error";
+  PRBEAgentErrorType2["NETWORK_ERROR"] = "network_error";
+  PRBEAgentErrorType2["CANCELLED"] = "cancelled";
+  PRBEAgentErrorType2["MAX_ITERATIONS"] = "max_iterations";
+  return PRBEAgentErrorType2;
+})(PRBEAgentErrorType || {});
+var PRBEAgentError = class extends Error {
+  errorType;
+  statusCode;
+  constructor(errorType, message, statusCode) {
+    super(message);
+    this.name = "PRBEAgentError";
+    this.errorType = errorType;
+    this.statusCode = statusCode;
+  }
+};
+function redactPII(text) {
+  return text;
+}
+var API_URL = "https://api.prbe.ai";
+var MIDDLEWARE_URL = "wss://middleware.prbe.ai";
+
+// src/state.ts
+import { EventEmitter } from "events";
+import { randomUUID } from "crypto";
+var PRBEStateEvent = /* @__PURE__ */ ((PRBEStateEvent2) => {
+  PRBEStateEvent2["STATUS"] = "status";
+  PRBEStateEvent2["EVENT"] = "event";
+  PRBEStateEvent2["COMPLETE"] = "complete";
+  PRBEStateEvent2["ERROR"] = "error";
+  PRBEStateEvent2["CR_START"] = "cr-start";
+  PRBEStateEvent2["CR_COMPLETE"] = "cr-complete";
+  PRBEStateEvent2["TICKETS_CHANGED"] = "tickets-changed";
+  PRBEStateEvent2["TICKET_INFO"] = "ticket-info";
+  PRBEStateEvent2["INTERACTION_REQUESTED"] = "interaction-requested";
+  PRBEStateEvent2["INTERACTION_RESOLVED"] = "interaction-resolved";
+  return PRBEStateEvent2;
+})(PRBEStateEvent || {});
+var PRBEAgentState = class extends EventEmitter {
+  // User-initiated investigation
+  isInvestigating = false;
+  events = [];
+  report = "";
+  summary = "";
+  currentQuery = "";
+  investigationError;
+  pendingInteraction;
+  resolvedInteractions = [];
+  // Completed user investigations (history)
+  completedInvestigations = [];
+  // Background context requests
+  activeCRs = /* @__PURE__ */ new Map();
+  completedCRs = [];
+  // Tracked tickets
+  trackedTicketIDs = [];
+  ticketInfo = [];
+  // Computed
+  get hasActiveWork() {
+    return this.isInvestigating || this.activeCRs.size > 0;
+  }
+  get activeCRCount() {
+    return this.activeCRs.size;
+  }
+  get isActive() {
+    return this.isInvestigating || this.report.length > 0 || this.investigationError != null;
+  }
+  // ---------- User investigation mutations ----------
+  beginInvestigation(query) {
+    this.isInvestigating = true;
+    this.events = [];
+    this.resolvedInteractions = [];
+    this.report = "";
+    this.summary = "";
+    this.currentQuery = query;
+    this.investigationError = void 0;
+    this.emit("status" /* STATUS */);
+  }
+  resetInvestigation() {
+    this.isInvestigating = false;
+    this.events = [];
+    this.resolvedInteractions = [];
+    this.report = "";
+    this.summary = "";
+    this.currentQuery = "";
+    this.investigationError = void 0;
+    this.pendingInteraction = void 0;
+    this.emit("status" /* STATUS */);
+  }
+  appendEvent(label, detail, completed = false) {
+    if (this.events.length > 0) {
+      const last = this.events[this.events.length - 1];
+      if (!last.isCompleted && !completed) {
+        last.isCompleted = true;
+      }
+    }
+    const event = {
+      id: randomUUID(),
+      label,
+      detail,
+      isCompleted: completed,
+      isExpanded: false
+    };
+    this.events.push(event);
+    this.emit("event" /* EVENT */, event);
+    this.emit("status" /* STATUS */);
+  }
+  attachObservation(text) {
+    if (this.events.length > 0) {
+      this.events[this.events.length - 1].detail = text;
+      this.emit("status" /* STATUS */);
+    }
+  }
+  completeInvestigation(report, summary) {
+    if (this.events.length > 0) {
+      this.events[this.events.length - 1].isCompleted = true;
+    }
+    this.appendEvent("Done", void 0, true);
+    this.completedInvestigations.unshift({
+      id: randomUUID(),
+      query: this.currentQuery,
+      report,
+      summary,
+      completedAt: /* @__PURE__ */ new Date()
+    });
+    this.report = report;
+    this.summary = summary;
+    this.isInvestigating = false;
+    this.emit("complete" /* COMPLETE */, { report, summary });
+    this.emit("status" /* STATUS */);
+  }
+  failInvestigation(message) {
+    this.appendEvent(`Error: ${message}`);
+    this.investigationError = message;
+    this.isInvestigating = false;
+    this.emit("error" /* ERROR */, { message });
+    this.emit("status" /* STATUS */);
+  }
+  // ---------- Interaction state mutations ----------
+  setPendingInteraction(payload) {
+    this.pendingInteraction = payload;
+    this.emit("interaction-requested" /* INTERACTION_REQUESTED */, payload);
+    this.emit("status" /* STATUS */);
+  }
+  clearPendingInteraction() {
+    this.pendingInteraction = void 0;
+    this.emit("interaction-resolved" /* INTERACTION_RESOLVED */);
+    this.emit("status" /* STATUS */);
+  }
+  setCRPendingInteraction(crID, payload) {
+    const cr = this.activeCRs.get(crID);
+    if (!cr) return;
+    cr.pendingInteraction = payload;
+    this.emit("interaction-requested" /* INTERACTION_REQUESTED */, payload);
+    this.emit("status" /* STATUS */);
+  }
+  clearCRPendingInteraction(crID) {
+    const cr = this.activeCRs.get(crID);
+    if (!cr) return;
+    cr.pendingInteraction = void 0;
+    this.emit("interaction-resolved" /* INTERACTION_RESOLVED */);
+    this.emit("status" /* STATUS */);
+  }
+  resolveInteraction(response) {
+    if (!this.pendingInteraction) return;
+    this.resolvedInteractions.push({
+      interactionId: this.pendingInteraction.interactionId,
+      payload: this.pendingInteraction,
+      response,
+      eventIndex: this.events.length
+    });
+    this.pendingInteraction = void 0;
+    this.emit("interaction-resolved" /* INTERACTION_RESOLVED */);
+    this.emit("status" /* STATUS */);
+  }
+  resolveCRInteraction(crID, response) {
+    const cr = this.activeCRs.get(crID);
+    if (!cr || !cr.pendingInteraction) return;
+    const resolved = cr.resolvedInteractions ?? [];
+    resolved.push({
+      interactionId: cr.pendingInteraction.interactionId,
+      payload: cr.pendingInteraction,
+      response,
+      eventIndex: cr.events.length
+    });
+    cr.resolvedInteractions = resolved;
+    cr.pendingInteraction = void 0;
+    this.emit("interaction-resolved" /* INTERACTION_RESOLVED */);
+    this.emit("status" /* STATUS */);
+  }
+  toggleExpansion(eventId) {
+    const event = this.events.find((e) => e.id === eventId);
+    if (event) {
+      event.isExpanded = !event.isExpanded;
+      this.emit("status" /* STATUS */);
+    }
+  }
+  // ---------- CR state mutations ----------
+  beginCR(id, query, slug) {
+    const cr = {
+      id,
+      query,
+      slug,
+      events: [],
+      resolvedInteractions: [],
+      isRunning: true,
+      isCompleted: false,
+      isFailed: false,
+      report: "",
+      summary: "",
+      startedAt: /* @__PURE__ */ new Date()
+    };
+    this.activeCRs.set(id, cr);
+    this.emit("cr-start" /* CR_START */, cr);
+    this.emit("status" /* STATUS */);
+  }
+  appendCREvent(crID, label, detail, completed = false) {
+    const cr = this.activeCRs.get(crID);
+    if (!cr) return;
+    if (cr.events.length > 0) {
+      const last = cr.events[cr.events.length - 1];
+      if (!last.isCompleted && !completed) {
+        last.isCompleted = true;
+      }
+    }
+    cr.events.push({
+      id: randomUUID(),
+      label,
+      detail,
+      isCompleted: completed,
+      isExpanded: false
+    });
+    this.emit("status" /* STATUS */);
+  }
+  attachCRObservation(crID, text) {
+    const cr = this.activeCRs.get(crID);
+    if (!cr || cr.events.length === 0) return;
+    cr.events[cr.events.length - 1].detail = text;
+    this.emit("status" /* STATUS */);
+  }
+  completeCR(id, report, summary) {
+    const cr = this.activeCRs.get(id);
+    if (!cr) return;
+    this.activeCRs.delete(id);
+    if (cr.events.length > 0) {
+      cr.events[cr.events.length - 1].isCompleted = true;
+    }
+    cr.events.push({
+      id: randomUUID(),
+      label: "Done",
+      isCompleted: true,
+      isExpanded: false
+    });
+    cr.isRunning = false;
+    cr.isCompleted = true;
+    cr.report = report;
+    cr.summary = summary;
+    this.completedCRs.unshift(cr);
+    this.emit("cr-complete" /* CR_COMPLETE */, cr);
+    this.emit("status" /* STATUS */);
+  }
+  failCR(id, message) {
+    const cr = this.activeCRs.get(id);
+    if (!cr) return;
+    this.activeCRs.delete(id);
+    cr.events.push({
+      id: randomUUID(),
+      label: `Error: ${message}`,
+      isCompleted: false,
+      isExpanded: false
+    });
+    cr.isRunning = false;
+    cr.isFailed = true;
+    cr.errorMessage = message;
+    this.completedCRs.unshift(cr);
+    this.emit("cr-complete" /* CR_COMPLETE */, cr);
+    this.emit("status" /* STATUS */);
+  }
+  // ---------- Tickets ----------
+  updateTrackedTicketIDs(ids) {
+    this.trackedTicketIDs = ids;
+    this.emit("tickets-changed" /* TICKETS_CHANGED */, ids);
+    this.emit("status" /* STATUS */);
+  }
+  updateTicketInfo(info) {
+    this.ticketInfo = info;
+    this.emit("ticket-info" /* TICKET_INFO */, info);
+    this.emit("status" /* STATUS */);
+  }
+};
+
+// src/tools/index.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/interactions.ts
+var InteractionType = /* @__PURE__ */ ((InteractionType2) => {
+  InteractionType2["ASK_QUESTION"] = "ask_question";
+  InteractionType2["REQUEST_PERMISSION"] = "request_permission";
+  InteractionType2["REQUEST_PATH_ACCESS"] = "request_path_access";
+  return InteractionType2;
+})(InteractionType || {});
+var InvestigationSource = /* @__PURE__ */ ((InvestigationSource2) => {
+  InvestigationSource2["USER"] = "user";
+  InvestigationSource2["CONTEXT_REQUEST"] = "context_request";
+  return InvestigationSource2;
+})(InvestigationSource || {});
+
+// src/tools/index.ts
+import * as path from "path";
+var PRBEToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  register(tool) {
+    this.tools.set(tool.declaration.name, tool);
+  }
+  allDeclarations() {
+    return Array.from(this.tools.values()).map((t) => t.declaration);
+  }
+  async execute(name, args) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return `Error: unknown tool '${name}'`;
+    }
+    return tool.execute(args);
+  }
+};
+var PRBEClosureTool = class {
+  declaration;
+  handler;
+  constructor(name, description, parameters, handler) {
+    this.declaration = { name, description, parameters };
+    this.handler = handler;
+  }
+  async execute(args) {
+    return this.handler(args);
+  }
+};
+function resolveAndValidate(pathStr, autoApprovedDirs) {
+  let resolved;
+  if (path.isAbsolute(pathStr)) {
+    resolved = path.resolve(pathStr);
+  } else if (autoApprovedDirs.length > 0) {
+    resolved = path.resolve(autoApprovedDirs[0], pathStr);
+  } else {
+    return null;
+  }
+  const normalizedResolved = path.resolve(resolved);
+  for (const root of autoApprovedDirs) {
+    const normalizedRoot = path.resolve(root);
+    if (normalizedResolved === normalizedRoot || normalizedResolved.startsWith(normalizedRoot + path.sep)) {
+      return normalizedResolved;
+    }
+  }
+  return null;
+}
+async function resolveWithAccessRequest(pathStr, autoApprovedDirs, grantedPaths, requester) {
+  const allRoots = [...autoApprovedDirs, ...grantedPaths];
+  const resolved = resolveAndValidate(pathStr, allRoots);
+  if (resolved) return { path: resolved };
+  if (!requester) return null;
+  let absolute;
+  if (path.isAbsolute(pathStr)) {
+    absolute = path.resolve(pathStr);
+  } else if (autoApprovedDirs.length > 0) {
+    absolute = path.resolve(autoApprovedDirs[0], pathStr);
+  } else {
+    return null;
+  }
+  const depth = absolute.split(path.sep).filter(Boolean).length;
+  if (depth < 3) {
+    return { error: `Path '${pathStr}' is too broad. Use a more specific path (e.g. a subdirectory at least 3 levels deep).` };
+  }
+  const response = await requester.requestUserInteraction({
+    type: "request_path_access" /* REQUEST_PATH_ACCESS */,
+    interactionId: randomUUID2(),
+    path: absolute,
+    reason: `The agent needs access to '${pathStr}' which is outside the allowed directories.`
+  });
+  const pathResponse = response;
+  if (!pathResponse.granted) return { error: "Path access denied by user." };
+  grantedPaths.add(absolute);
+  return { path: absolute };
+}
+function humanReadableSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(1)} KB`;
+  const mb = kb / 1024;
+  if (mb < 1024) return `${mb.toFixed(1)} MB`;
+  const gb = mb / 1024;
+  return `${gb.toFixed(1)} GB`;
+}
+
+// src/tools/filesystem.ts
+import * as fs from "fs";
+import * as path2 from "path";
+async function resolvePath(pathStr, autoApprovedDirs, requester, grantedPaths) {
+  if (requester && grantedPaths) {
+    const result = await resolveWithAccessRequest(pathStr, autoApprovedDirs, grantedPaths, requester);
+    if (result && "error" in result) return [null, result.error];
+    if (result && "path" in result) return [result.path, null];
+  }
+  const resolved = resolveAndValidate(pathStr, autoApprovedDirs);
+  return [resolved, resolved ? null : "path is outside auto-approved directories"];
+}
+var ListDirectoryTool = class _ListDirectoryTool {
+  autoApprovedDirs;
+  requester;
+  grantedPaths;
+  constructor(autoApprovedDirs, requester, grantedPaths) {
+    this.autoApprovedDirs = autoApprovedDirs;
+    this.requester = requester;
+    this.grantedPaths = grantedPaths;
+  }
+  get declaration() {
+    return {
+      name: "client_list_directory" /* CLIENT_LIST_DIRECTORY */,
+      description: "List directory contents",
+      parameters: [
+        { name: "path", type: "STRING" /* STRING */, description: "Directory path", required: true },
+        { name: "recursive", type: "BOOLEAN" /* BOOLEAN */, description: "List recursively", required: false },
+        { name: "max_depth", type: "INTEGER" /* INTEGER */, description: "Max depth (default 3)", required: false }
+      ]
+    };
+  }
+  async execute(args) {
+    const pathStr = args["path"];
+    if (!pathStr) return "Error: 'path' parameter is required";
+    const [resolved, resolveErr] = await resolvePath(pathStr, this.autoApprovedDirs, this.requester, this.grantedPaths);
+    if (!resolved) return `Error: ${resolveErr}`;
+    try {
+      const stat = fs.statSync(resolved);
+      if (!stat.isDirectory()) return `Error: '${pathStr}' is not a directory`;
+    } catch {
+      return `Error: '${pathStr}' does not exist or is not accessible`;
+    }
+    const recursive = args["recursive"] === true;
+    const maxDepth = typeof args["max_depth"] === "number" ? args["max_depth"] : 3;
+    const lines = [];
+    this.listDir(resolved, 0, recursive ? maxDepth : 1, lines);
+    if (lines.length >= _ListDirectoryTool.MAX_ENTRIES) {
+      lines.push(`
+(truncated at ${_ListDirectoryTool.MAX_ENTRIES} entries \u2014 use a more specific path)`);
+    }
+    return lines.join("\n") || "(empty directory)";
+  }
+  static MAX_ENTRIES = 1e3;
+  listDir(dirPath, depth, maxDepth, lines) {
+    if (depth >= maxDepth) return;
+    if (lines.length >= _ListDirectoryTool.MAX_ENTRIES) return;
+    const indent = "  ".repeat(depth);
+    let entries;
+    try {
+      entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+      lines.push(`${indent}(access denied)`);
+      return;
+    }
+    const sorted = entries.filter((e) => !e.name.startsWith(".")).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of sorted) {
+      const fullPath = path2.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        lines.push(`${indent}${entry.name}/`);
+        this.listDir(fullPath, depth + 1, maxDepth, lines);
+      } else {
+        try {
+          const stat = fs.statSync(fullPath);
+          lines.push(`${indent}${entry.name}  (${humanReadableSize(stat.size)})`);
+        } catch {
+          lines.push(`${indent}${entry.name}  (unknown size)`);
+        }
+      }
+    }
+  }
+};
+var ReadFileTool = class {
+  autoApprovedDirs;
+  requester;
+  grantedPaths;
+  constructor(autoApprovedDirs, requester, grantedPaths) {
+    this.autoApprovedDirs = autoApprovedDirs;
+    this.requester = requester;
+    this.grantedPaths = grantedPaths;
+  }
+  get declaration() {
+    return {
+      name: "client_read_file" /* CLIENT_READ_FILE */,
+      description: "Read file contents",
+      parameters: [
+        { name: "path", type: "STRING" /* STRING */, description: "File path", required: true },
+        { name: "offset", type: "INTEGER" /* INTEGER */, description: "Line offset", required: false },
+        { name: "limit", type: "INTEGER" /* INTEGER */, description: "Max lines (default 200)", required: false }
+      ]
+    };
+  }
+  async execute(args) {
+    const pathStr = args["path"];
+    if (!pathStr) return "Error: 'path' parameter is required";
+    const [resolved, resolveErr] = await resolvePath(pathStr, this.autoApprovedDirs, this.requester, this.grantedPaths);
+    if (!resolved) return `Error: ${resolveErr}`;
+    let content;
+    try {
+      content = fs.readFileSync(resolved, "utf-8");
+    } catch {
+      return `Error: could not read file at '${pathStr}'`;
+    }
+    const allLines = content.split(/\r?\n/);
+    const totalLines = allLines.length;
+    const limit = typeof args["limit"] === "number" ? args["limit"] : 200;
+    const rawOffset = typeof args["offset"] === "number" ? args["offset"] : 0;
+    let startIndex;
+    if (rawOffset < 0) {
+      startIndex = Math.max(0, totalLines + rawOffset);
+    } else {
+      startIndex = rawOffset;
+    }
+    const endIndex = Math.min(startIndex + limit, totalLines);
+    if (startIndex >= totalLines) {
+      return `File has ${totalLines} lines; offset ${rawOffset} is out of range.`;
+    }
+    let stat;
+    try {
+      stat = fs.statSync(resolved);
+    } catch {
+      stat = { size: 0 };
+    }
+    const sizeStr = humanReadableSize(stat.size);
+    let result = `File: ${pathStr} (${totalLines} lines, ${sizeStr}, showing ${startIndex + 1}-${endIndex})
+`;
+    for (let i = startIndex; i < endIndex; i++) {
+      const lineNum = String(i + 1).padStart(4, " ");
+      result += `${lineNum} | ${allLines[i]}
+`;
+    }
+    return result;
+  }
+};
+var SearchContentTool = class {
+  autoApprovedDirs;
+  requester;
+  grantedPaths;
+  constructor(autoApprovedDirs, requester, grantedPaths) {
+    this.autoApprovedDirs = autoApprovedDirs;
+    this.requester = requester;
+    this.grantedPaths = grantedPaths;
+  }
+  get declaration() {
+    return {
+      name: "client_search_content" /* CLIENT_SEARCH_CONTENT */,
+      description: "Search file contents",
+      parameters: [
+        { name: "pattern", type: "STRING" /* STRING */, description: "Regex pattern", required: true },
+        { name: "path", type: "STRING" /* STRING */, description: "File or directory to search", required: true },
+        { name: "context_lines", type: "INTEGER" /* INTEGER */, description: "Context lines (default 2)", required: false },
+        { name: "max_results", type: "INTEGER" /* INTEGER */, description: "Max results (default 50)", required: false }
+      ]
+    };
+  }
+  async execute(args) {
+    const pattern = args["pattern"];
+    if (!pattern) return "Error: 'pattern' parameter is required";
+    const pathStr = args["path"];
+    if (!pathStr) return "Error: 'path' parameter is required";
+    const [resolved, resolveErr] = await resolvePath(pathStr, this.autoApprovedDirs, this.requester, this.grantedPaths);
+    if (!resolved) return `Error: ${resolveErr}`;
+    const contextLines = typeof args["context_lines"] === "number" ? args["context_lines"] : 2;
+    const maxResults = typeof args["max_results"] === "number" ? args["max_results"] : 50;
+    let regex;
+    try {
+      regex = new RegExp(pattern);
+    } catch {
+      return `Error: invalid regex pattern '${pattern}'`;
+    }
+    const fileURLs = [];
+    let isDirectory = false;
+    try {
+      const stat = fs.statSync(resolved);
+      if (stat.isDirectory()) {
+        isDirectory = true;
+        this.collectFiles(resolved, fileURLs);
+      } else {
+        fileURLs.push(resolved);
+      }
+    } catch {
+      return `Error: could not access '${pathStr}'`;
+    }
+    const results = [];
+    for (const filePath of fileURLs) {
+      if (results.length >= maxResults) break;
+      let content;
+      try {
+        content = fs.readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+      const lines = content.split(/\r?\n/);
+      const relativePath = isDirectory ? path2.relative(resolved, filePath) : path2.basename(filePath);
+      for (let idx = 0; idx < lines.length; idx++) {
+        if (results.length >= maxResults) break;
+        if (!regex.test(lines[idx])) continue;
+        let snippet;
+        if (contextLines > 0) {
+          const start = Math.max(0, idx - contextLines);
+          const end = Math.min(lines.length - 1, idx + contextLines);
+          snippet = "";
+          for (let ci = start; ci <= end; ci++) {
+            const marker = ci === idx ? ">" : " ";
+            snippet += `${relativePath}:${ci + 1}:${marker} ${lines[ci]}
+`;
+          }
+        } else {
+          snippet = `${relativePath}:${idx + 1}: ${lines[idx]}`;
+        }
+        results.push(snippet);
+      }
+    }
+    if (results.length === 0) {
+      return `No matches found for '${pattern}' in '${pathStr}'`;
+    }
+    return `Found ${results.length} match(es):
+
+${results.join("\n---\n")}`;
+  }
+  collectFiles(dirPath, fileURLs) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = path2.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        this.collectFiles(fullPath, fileURLs);
+      } else if (entry.isFile()) {
+        fileURLs.push(fullPath);
+      }
+    }
+  }
+};
+var FindFilesTool = class {
+  autoApprovedDirs;
+  requester;
+  grantedPaths;
+  constructor(autoApprovedDirs, requester, grantedPaths) {
+    this.autoApprovedDirs = autoApprovedDirs;
+    this.requester = requester;
+    this.grantedPaths = grantedPaths;
+  }
+  get declaration() {
+    return {
+      name: "client_find_files" /* CLIENT_FIND_FILES */,
+      description: "Find files by name",
+      parameters: [
+        { name: "pattern", type: "STRING" /* STRING */, description: "Glob pattern", required: true },
+        { name: "path", type: "STRING" /* STRING */, description: "Directory to search", required: true },
+        { name: "max_results", type: "INTEGER" /* INTEGER */, description: "Max results (default 50)", required: false }
+      ]
+    };
+  }
+  async execute(args) {
+    const pattern = args["pattern"];
+    if (!pattern) return "Error: 'pattern' parameter is required";
+    const pathStr = args["path"];
+    if (!pathStr) return "Error: 'path' parameter is required";
+    const [resolved, resolveErr] = await resolvePath(pathStr, this.autoApprovedDirs, this.requester, this.grantedPaths);
+    if (!resolved) return `Error: ${resolveErr}`;
+    const maxResults = typeof args["max_results"] === "number" ? args["max_results"] : 50;
+    const matches = [];
+    this.walkAndMatch(resolved, pattern, matches);
+    matches.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    const limited = matches.slice(0, maxResults);
+    if (limited.length === 0) {
+      return `No files matching '${pattern}' found in '${pathStr}'`;
+    }
+    let result = `Found ${matches.length} file(s) matching '${pattern}':
+
+`;
+    for (const m of limited) {
+      const sizeStr = humanReadableSize(m.size);
+      const dateStr = m.modified.toISOString();
+      result += `${m.path}  (${sizeStr}, ${dateStr})
+`;
+    }
+    return result;
+  }
+  walkAndMatch(dirPath, pattern, matches) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const fullPath = path2.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        this.walkAndMatch(fullPath, pattern, matches);
+      } else if (entry.isFile()) {
+        if (this.globMatch(entry.name, pattern)) {
+          try {
+            const stat = fs.statSync(fullPath);
+            matches.push({
+              path: fullPath,
+              size: stat.size,
+              modified: stat.mtime
+            });
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Simple glob matching: supports *, ?, and character classes [...].
+   * Converts glob to regex and tests against the filename.
+   */
+  globMatch(filename, pattern) {
+    let regexStr = "^";
+    for (let i = 0; i < pattern.length; i++) {
+      const c = pattern[i];
+      switch (c) {
+        case "*":
+          regexStr += ".*";
+          break;
+        case "?":
+          regexStr += ".";
+          break;
+        case "[":
+          const closeBracket = pattern.indexOf("]", i + 1);
+          if (closeBracket === -1) {
+            regexStr += "\\[";
+          } else {
+            regexStr += pattern.substring(i, closeBracket + 1);
+            i = closeBracket;
+          }
+          break;
+        case ".":
+        case "(":
+        case ")":
+        case "+":
+        case "^":
+        case "$":
+        case "|":
+        case "{":
+        case "}":
+        case "\\":
+          regexStr += `\\${c}`;
+          break;
+        default:
+          regexStr += c;
+      }
+    }
+    regexStr += "$";
+    try {
+      return new RegExp(regexStr).test(filename);
+    } catch {
+      return false;
+    }
+  }
+};
+var FlagFileTool = class _FlagFileTool {
+  autoApprovedDirs;
+  onFlag;
+  requester;
+  grantedPaths;
+  static MAX_BINARY_SIZE = 100 * 1024 * 1024;
+  // 100MB
+  constructor(autoApprovedDirs, onFlag, requester, grantedPaths) {
+    this.autoApprovedDirs = autoApprovedDirs;
+    this.onFlag = onFlag;
+    this.requester = requester;
+    this.grantedPaths = grantedPaths;
+  }
+  get declaration() {
+    return {
+      name: "client_flag_file" /* CLIENT_FLAG_FILE */,
+      description: "Flag a file (or part of a text file) as evidence. For large text files, use offset and limit to flag only the relevant section. Binary files are flagged in full (up to 100MB).",
+      parameters: [
+        { name: "path", type: "STRING" /* STRING */, description: "File path", required: true },
+        { name: "reason", type: "STRING" /* STRING */, description: "Reason for flagging", required: true },
+        { name: "offset", type: "INTEGER" /* INTEGER */, description: "Starting line number (1-based, text files only). Negative = from end.", required: false },
+        { name: "limit", type: "INTEGER" /* INTEGER */, description: "Max number of lines to include (text files only).", required: false }
+      ]
+    };
+  }
+  async execute(args) {
+    const pathStr = args["path"];
+    if (!pathStr) return "Error: 'path' parameter is required";
+    const reason = args["reason"];
+    if (!reason) return "Error: 'reason' parameter is required";
+    const [resolved, resolveErr] = await resolvePath(pathStr, this.autoApprovedDirs, this.requester, this.grantedPaths);
+    if (!resolved) return `Error: ${resolveErr}`;
+    if (!fs.existsSync(resolved)) {
+      return `Error: file does not exist at '${pathStr}'`;
+    }
+    const offset = typeof args["offset"] === "number" ? args["offset"] : void 0;
+    const limit = typeof args["limit"] === "number" ? args["limit"] : void 0;
+    let textContent = null;
+    try {
+      textContent = fs.readFileSync(resolved, "utf-8");
+    } catch {
+    }
+    if (textContent !== null) {
+      let content = textContent;
+      if (offset !== void 0 || limit !== void 0) {
+        let lines = content.split(/\r?\n/);
+        const totalLines = lines.length;
+        let startIdx = 0;
+        if (offset !== void 0) {
+          startIdx = offset < 0 ? Math.max(0, totalLines + offset) : Math.max(0, offset - 1);
+        }
+        lines = lines.slice(startIdx);
+        if (limit !== void 0 && limit > 0) {
+          lines = lines.slice(0, limit);
+        }
+        const rangeDesc = `lines ${startIdx + 1}-${startIdx + lines.length} of ${totalLines}`;
+        content = `[${rangeDesc}]
+${lines.join("\n")}`;
+      }
+      const redacted = redactPII(content);
+      this.onFlag({
+        originalPath: resolved,
+        reason,
+        data: Buffer.from(redacted, "utf-8"),
+        isText: true
+      });
+      const sizeDesc = offset !== void 0 || limit !== void 0 ? " (partial)" : "";
+      return `Flagged '${pathStr}'${sizeDesc} \u2014 reason: ${reason}`;
+    }
+    if (offset !== void 0 || limit !== void 0) {
+      return "Error: offset/limit not supported for binary files. Flag the full file instead.";
+    }
+    let data;
+    try {
+      data = fs.readFileSync(resolved);
+    } catch {
+      return `Error: could not read file at '${pathStr}'`;
+    }
+    if (data.length > _FlagFileTool.MAX_BINARY_SIZE) {
+      const sizeMB = Math.floor(data.length / (1024 * 1024));
+      return `Error: file is ${sizeMB}MB \u2014 exceeds 100MB limit`;
+    }
+    this.onFlag({
+      originalPath: resolved,
+      reason,
+      data,
+      isText: false
+    });
+    return `Flagged '${pathStr}' (binary, ${data.length} bytes) \u2014 reason: ${reason}`;
+  }
+};
+
+// src/tools/logs.ts
+var PRBELogCapture = class {
+  entries = [];
+  maxEntries;
+  isCapturing = false;
+  // Original console methods, saved for restoration
+  originalLog;
+  originalWarn;
+  originalError;
+  originalDebug;
+  originalInfo;
+  constructor(maxEntries = 1e4) {
+    this.maxEntries = maxEntries;
+  }
+  // ---------- Structured Logging ----------
+  log(message, level = "PRINT", category = "print") {
+    this.append({
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      category,
+      message
+    });
+  }
+  // ---------- Query ----------
+  get count() {
+    return this.entries.length;
+  }
+  getEntries(options = {}) {
+    const { offset = 0, limit = 100, level, from, to } = options;
+    let filtered = this.entries;
+    if (level) {
+      filtered = filtered.filter((e) => e.level === level);
+    }
+    if (from) {
+      filtered = filtered.filter((e) => e.timestamp >= from);
+    }
+    if (to) {
+      filtered = filtered.filter((e) => e.timestamp <= to);
+    }
+    if (offset >= filtered.length) return [];
+    const end = Math.min(offset + limit, filtered.length);
+    return filtered.slice(offset, end);
+  }
+  search(pattern, contextLines = 2, maxResults = 50) {
+    let regex;
+    try {
+      regex = new RegExp(pattern, "i");
+    } catch {
+      return [];
+    }
+    const results = [];
+    for (let i = 0; i < this.entries.length; i++) {
+      if (results.length >= maxResults) break;
+      if (regex.test(this.entries[i].message)) {
+        results.push({ index: i, entry: this.entries[i] });
+      }
+    }
+    return results;
+  }
+  // ---------- Clear ----------
+  clearLogs() {
+    const count = this.entries.length;
+    this.entries = [];
+    return count;
+  }
+  // ---------- Console Capture ----------
+  startCapturing() {
+    if (this.isCapturing) return;
+    this.isCapturing = true;
+    this.originalLog = console.log;
+    this.originalWarn = console.warn;
+    this.originalError = console.error;
+    this.originalDebug = console.debug;
+    this.originalInfo = console.info;
+    const self = this;
+    console.log = (...args) => {
+      self.originalLog?.apply(console, args);
+      self.log(args.map(String).join(" "), "PRINT", "console.log");
+    };
+    console.warn = (...args) => {
+      self.originalWarn?.apply(console, args);
+      self.log(args.map(String).join(" "), "WARNING", "console.warn");
+    };
+    console.error = (...args) => {
+      self.originalError?.apply(console, args);
+      self.log(args.map(String).join(" "), "ERROR", "console.error");
+    };
+    console.debug = (...args) => {
+      self.originalDebug?.apply(console, args);
+      self.log(args.map(String).join(" "), "DEBUG", "console.debug");
+    };
+    console.info = (...args) => {
+      self.originalInfo?.apply(console, args);
+      self.log(args.map(String).join(" "), "INFO", "console.info");
+    };
+  }
+  stopCapturing() {
+    if (!this.isCapturing) return;
+    this.isCapturing = false;
+    if (this.originalLog) console.log = this.originalLog;
+    if (this.originalWarn) console.warn = this.originalWarn;
+    if (this.originalError) console.error = this.originalError;
+    if (this.originalDebug) console.debug = this.originalDebug;
+    if (this.originalInfo) console.info = this.originalInfo;
+    this.originalLog = void 0;
+    this.originalWarn = void 0;
+    this.originalError = void 0;
+    this.originalDebug = void 0;
+    this.originalInfo = void 0;
+  }
+  // ---------- Raw access to all entries (for tools) ----------
+  getAllEntries() {
+    return this.entries;
+  }
+  // ---------- Private ----------
+  append(entry) {
+    this.entries.push(entry);
+    if (this.entries.length > this.maxEntries) {
+      this.entries.splice(0, this.entries.length - this.maxEntries);
+    }
+  }
+};
+var ReadAppLogsTool = class {
+  logCapture;
+  constructor(logCapture) {
+    this.logCapture = logCapture;
+  }
+  get declaration() {
+    return {
+      name: "client_read_app_logs" /* CLIENT_READ_APP_LOGS */,
+      description: "Read application log entries captured from stdout and structured logging",
+      parameters: [
+        { name: "position", type: "STRING" /* STRING */, description: '"top" (oldest first) or "bottom" (newest first). Default: "bottom"', required: false },
+        { name: "count", type: "INTEGER" /* INTEGER */, description: "Number of entries to return. Default: 100", required: false },
+        { name: "level", type: "STRING" /* STRING */, description: 'Filter by log level (e.g. "ERROR", "INFO", "PRINT")', required: false },
+        { name: "from", type: "STRING" /* STRING */, description: "ISO8601 start timestamp filter", required: false },
+        { name: "to", type: "STRING" /* STRING */, description: "ISO8601 end timestamp filter", required: false }
+      ]
+    };
+  }
+  async execute(args) {
+    const position = args["position"] ?? "bottom";
+    const count = typeof args["count"] === "number" ? args["count"] : 100;
+    const level = args["level"];
+    const fromDate = args["from"] ? new Date(args["from"]) : void 0;
+    const toDate = args["to"] ? new Date(args["to"]) : void 0;
+    const totalCount = this.logCapture.count;
+    const allEntries = this.logCapture.getEntries({
+      offset: 0,
+      limit: totalCount,
+      level,
+      from: fromDate,
+      to: toDate
+    });
+    if (allEntries.length === 0) {
+      return "No log entries found matching the specified filters.";
+    }
+    let selected;
+    if (position === "top") {
+      selected = allEntries.slice(0, count);
+    } else {
+      selected = allEntries.slice(-count);
+    }
+    let result = `Log entries (${selected.length} of ${allEntries.length} total):
+
+`;
+    for (const entry of selected) {
+      result += `[${entry.timestamp.toISOString()}] [${entry.level}] [${entry.category}] ${entry.message}
+`;
+    }
+    return result;
+  }
+};
+var SearchAppLogsTool = class {
+  logCapture;
+  constructor(logCapture) {
+    this.logCapture = logCapture;
+  }
+  get declaration() {
+    return {
+      name: "client_search_app_logs" /* CLIENT_SEARCH_APP_LOGS */,
+      description: "Search application logs by regex pattern with surrounding context",
+      parameters: [
+        { name: "pattern", type: "STRING" /* STRING */, description: "Regex pattern to search for", required: true },
+        { name: "context_lines", type: "INTEGER" /* INTEGER */, description: "Number of surrounding log entries for context. Default: 2", required: false },
+        { name: "max_results", type: "INTEGER" /* INTEGER */, description: "Maximum matches to return. Default: 50", required: false }
+      ]
+    };
+  }
+  async execute(args) {
+    const pattern = args["pattern"];
+    if (!pattern) return "Error: 'pattern' parameter is required";
+    const contextLines = typeof args["context_lines"] === "number" ? args["context_lines"] : 2;
+    const maxResults = typeof args["max_results"] === "number" ? args["max_results"] : 50;
+    const matches = this.logCapture.search(pattern, contextLines, maxResults);
+    if (matches.length === 0) {
+      return `No log entries matching '${pattern}' found.`;
+    }
+    const allEntries = this.logCapture.getAllEntries();
+    let result = `Found ${matches.length} match(es) for '${pattern}':
+
+`;
+    for (const match of matches) {
+      const startIdx = Math.max(0, match.index - contextLines);
+      const endIdx = Math.min(allEntries.length - 1, match.index + contextLines);
+      for (let i = startIdx; i <= endIdx; i++) {
+        const entry = allEntries[i];
+        const marker = i === match.index ? ">" : " ";
+        result += `${marker} [${entry.timestamp.toISOString()}] [${entry.level}] [${entry.category}] ${entry.message}
+`;
+      }
+      result += "---\n";
+    }
+    return result;
+  }
+};
+var ClearAppLogsTool = class {
+  logCapture;
+  constructor(logCapture) {
+    this.logCapture = logCapture;
+  }
+  get declaration() {
+    return {
+      name: "client_clear_app_logs" /* CLIENT_CLEAR_APP_LOGS */,
+      description: "Clear all captured application logs",
+      parameters: []
+    };
+  }
+  async execute(_args) {
+    const cleared = this.logCapture.clearLogs();
+    return `Cleared ${cleared} log entries.`;
+  }
+};
+var FlagAppLogsTool = class {
+  logCapture;
+  onFlag;
+  constructor(logCapture, onFlag) {
+    this.logCapture = logCapture;
+    this.onFlag = onFlag;
+  }
+  get declaration() {
+    return {
+      name: "client_flag_app_logs" /* CLIENT_FLAG_APP_LOGS */,
+      description: "Flag application log entries as evidence for the debug report. Snapshots matching log entries and includes them in the output package. Call with no filters to flag all logs, or use pattern to filter by message content. Note: 'level' filters by the log level metadata (e.g. PRINT, ERROR), NOT by message content \u2014 use 'pattern' to match words in log messages.",
+      parameters: [
+        { name: "reason", type: "STRING" /* STRING */, description: "Why these logs are relevant", required: true },
+        { name: "pattern", type: "STRING" /* STRING */, description: "Regex pattern to filter log messages by content", required: false },
+        { name: "level", type: "STRING" /* STRING */, description: "Filter by log level metadata (PRINT, DEBUG, INFO, ERROR, etc.) \u2014 this is NOT a content search", required: false },
+        { name: "from", type: "STRING" /* STRING */, description: "ISO8601 start timestamp filter", required: false },
+        { name: "to", type: "STRING" /* STRING */, description: "ISO8601 end timestamp filter", required: false }
+      ]
+    };
+  }
+  async execute(args) {
+    const reason = args["reason"];
+    if (!reason) return "Error: 'reason' parameter is required";
+    const level = args["level"];
+    const fromDate = args["from"] ? new Date(args["from"]) : void 0;
+    const toDate = args["to"] ? new Date(args["to"]) : void 0;
+    const totalCount = this.logCapture.count;
+    let entries = this.logCapture.getEntries({
+      offset: 0,
+      limit: totalCount,
+      level,
+      from: fromDate,
+      to: toDate
+    });
+    const patternStr = args["pattern"];
+    if (patternStr) {
+      let regex;
+      try {
+        regex = new RegExp(patternStr, "i");
+      } catch {
+        return `Error: invalid regex pattern '${patternStr}'`;
+      }
+      entries = entries.filter((entry) => regex.test(entry.message));
+    }
+    if (entries.length === 0) {
+      const filters = [];
+      if (level) filters.push(`level=${level}`);
+      if (patternStr) filters.push(`pattern=${patternStr}`);
+      if (fromDate) filters.push(`from=${args["from"]}`);
+      if (toDate) filters.push(`to=${args["to"]}`);
+      const hint = filters.length === 0 ? `The log buffer is empty (${totalCount} entries).` : `No entries matched filters: ${filters.join(", ")}. Total log entries: ${totalCount}. Try calling with no filters, or use 'pattern' instead of 'level' to match message content.`;
+      return hint;
+    }
+    let content = "";
+    for (const entry of entries) {
+      content += `[${entry.timestamp.toISOString()}] [${entry.level}] [${entry.category}] ${entry.message}
+`;
+    }
+    const nameParts = ["app_logs"];
+    if (level) nameParts.push(level.toLowerCase());
+    if (patternStr) {
+      const safe = patternStr.replace(/[^a-zA-Z0-9]/g, "_");
+      const trimmed = safe.substring(0, 30).replace(/^_+|_+$/g, "");
+      if (trimmed.length > 0) nameParts.push(trimmed);
+    }
+    const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:\-]/g, "").substring(0, 15);
+    nameParts.push(ts);
+    const filename = nameParts.join("_") + ".txt";
+    this.onFlag({
+      originalPath: filename,
+      reason,
+      data: Buffer.from(redactPII(content), "utf-8"),
+      isText: true
+    });
+    return `Flagged ${entries.length} log entries as '${filename}' \u2014 reason: ${reason}`;
+  }
+};
+
+// src/tools/interactive.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var AskUserTool = class {
+  requester;
+  constructor(requester) {
+    this.requester = requester;
+  }
+  get declaration() {
+    return {
+      name: "client_ask_user" /* CLIENT_ASK_USER */,
+      description: "Ask the user a question and wait for their response. Use this when you need clarification or additional information from the user to continue the investigation.",
+      interactive: true,
+      parameters: [
+        {
+          name: "question",
+          type: "STRING" /* STRING */,
+          description: "The question to ask the user",
+          required: true
+        },
+        {
+          name: "context",
+          type: "STRING" /* STRING */,
+          description: "Optional context explaining why you need this information",
+          required: false
+        }
+      ]
+    };
+  }
+  async execute(args) {
+    const question = args["question"];
+    if (!question) return "Error: 'question' parameter is required";
+    if (this.requester.investigationSource !== "user" /* USER */) {
+      return "This is a context request investigation \u2014 you cannot ask the user questions. Use the available tools to answer the query autonomously.";
+    }
+    const context = args["context"];
+    const response = await this.requester.requestUserInteraction({
+      type: "ask_question" /* ASK_QUESTION */,
+      interactionId: randomUUID3(),
+      question,
+      context
+    });
+    const askResponse = response;
+    return askResponse.answer;
+  }
+};
+
+// src/tools/bash.ts
+import { exec } from "child_process";
+import { randomUUID as randomUUID4 } from "crypto";
+import * as path3 from "path";
+var IS_WINDOWS = process.platform === "win32";
+var UNIX_SAFE_COMMANDS = /* @__PURE__ */ new Set([
+  "ls",
+  "cat",
+  "head",
+  "tail",
+  "grep",
+  "rg",
+  "find",
+  "which",
+  "whoami",
+  "pwd",
+  "echo",
+  "printf",
+  "wc",
+  "sort",
+  "uniq",
+  "diff",
+  "file",
+  "stat",
+  "du",
+  "df",
+  "uname",
+  "env",
+  "printenv",
+  "date",
+  "id",
+  "hostname",
+  "ps",
+  "top",
+  "uptime",
+  "free"
+]);
+var WINDOWS_SAFE_COMMANDS = /* @__PURE__ */ new Set([
+  "dir",
+  "type",
+  "findstr",
+  "where",
+  "whoami",
+  "echo",
+  "sort",
+  "fc",
+  "hostname",
+  "date",
+  "systeminfo",
+  "tasklist",
+  "set",
+  "ver",
+  "vol",
+  "tree",
+  // PowerShell cmdlets (when shell is PowerShell)
+  "get-childitem",
+  "get-content",
+  "select-string",
+  "get-process",
+  "get-date",
+  "get-host",
+  "get-computerinfo",
+  "get-volume",
+  "test-path",
+  "resolve-path",
+  "measure-object"
+]);
+var SAFE_COMMANDS = IS_WINDOWS ? WINDOWS_SAFE_COMMANDS : UNIX_SAFE_COMMANDS;
+var SAFE_COMMAND_PREFIXES = /* @__PURE__ */ new Set([
+  "git status",
+  "git log",
+  "git diff",
+  "git show",
+  "git branch",
+  "node --version",
+  "npm --version",
+  "npm list",
+  "npm ls"
+]);
+var MAX_OUTPUT_BYTES = 100 * 1024;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var MAX_TIMEOUT_MS = 12e4;
+var BashExecuteTool = class {
+  requester;
+  autoApprovedDirs;
+  grantedPaths;
+  constructor(requester, autoApprovedDirs, grantedPaths) {
+    this.requester = requester;
+    this.autoApprovedDirs = autoApprovedDirs;
+    this.grantedPaths = grantedPaths;
+  }
+  get declaration() {
+    return {
+      name: "client_bash_execute" /* CLIENT_BASH_EXECUTE */,
+      description: "Execute a shell command on the user's machine. Safe read-only commands run immediately; potentially destructive commands require user approval first.",
+      interactive: true,
+      parameters: [
+        {
+          name: "command",
+          type: "STRING" /* STRING */,
+          description: "The shell command to execute",
+          required: true
+        },
+        {
+          name: "cwd",
+          type: "STRING" /* STRING */,
+          description: "Working directory for the command (must be within auto-approved directories)",
+          required: false
+        },
+        {
+          name: "timeout",
+          type: "INTEGER" /* INTEGER */,
+          description: "Timeout in seconds (default 30, max 120)",
+          required: false
+        }
+      ]
+    };
+  }
+  async execute(args) {
+    const command = args["command"];
+    if (!command) return "Error: 'command' parameter is required";
+    const cwdArg = args["cwd"];
+    const timeoutSec = typeof args["timeout"] === "number" ? args["timeout"] : DEFAULT_TIMEOUT_MS / 1e3;
+    const timeoutMs = Math.min(timeoutSec * 1e3, MAX_TIMEOUT_MS);
+    let cwd;
+    if (cwdArg) {
+      const allRoots = [...this.autoApprovedDirs, ...this.grantedPaths];
+      const resolved = resolveAndValidate(cwdArg, allRoots);
+      if (!resolved) {
+        return `Error: working directory '${cwdArg}' is outside auto-approved directories`;
+      }
+      cwd = resolved;
+    }
+    const isSafe = this.isCommandSafe(command);
+    if (!isSafe) {
+      const response = await this.requester.requestUserInteraction({
+        type: "request_permission" /* REQUEST_PERMISSION */,
+        interactionId: randomUUID4(),
+        action: "Execute shell command",
+        command,
+        reason: `The agent wants to run this command${cwd ? ` in ${cwd}` : ""}.`
+      });
+      const permResponse = response;
+      if (!permResponse.approved) {
+        return "Command execution denied by user.";
+      }
+    }
+    return new Promise((resolve2) => {
+      exec(
+        command,
+        {
+          cwd,
+          timeout: timeoutMs,
+          maxBuffer: MAX_OUTPUT_BYTES,
+          env: process.env,
+          // On Windows, use PowerShell for more consistent behavior
+          ...IS_WINDOWS ? { shell: "powershell.exe" } : {}
+        },
+        (error, stdout, stderr) => {
+          let output = "";
+          if (stdout) {
+            output += stdout;
+          }
+          if (stderr) {
+            if (output) output += "\n--- stderr ---\n";
+            output += stderr;
+          }
+          if (error) {
+            if (error.killed) {
+              output += `
+[Command timed out after ${timeoutSec}s]`;
+            } else if (!stdout && !stderr) {
+              output = `Error: ${error.message}`;
+            }
+          }
+          if (Buffer.byteLength(output, "utf-8") > MAX_OUTPUT_BYTES) {
+            output = output.slice(0, MAX_OUTPUT_BYTES) + "\n[Output truncated at 100KB]";
+          }
+          resolve2(output || "(no output)");
+        }
+      );
+    });
+  }
+  /**
+   * Check if a command is on the safe whitelist.
+   */
+  isCommandSafe(command) {
+    const trimmed = command.trim();
+    for (const prefix of SAFE_COMMAND_PREFIXES) {
+      if (trimmed === prefix || trimmed.startsWith(prefix + " ")) {
+        return true;
+      }
+    }
+    const firstCommand = IS_WINDOWS ? trimmed.split(/[|;]/, 1)[0].trim() : trimmed.split(/[|;&]/, 1)[0].trim();
+    const baseCommand = firstCommand.split(/\s+/, 1)[0];
+    const commandName = IS_WINDOWS ? baseCommand.toLowerCase() : path3.basename(baseCommand);
+    if (SAFE_COMMANDS.has(commandName)) {
+      return this.areAllPipeSegmentsSafe(trimmed);
+    }
+    return false;
+  }
+  /**
+   * For piped commands, check that every segment uses a safe command.
+   */
+  areAllPipeSegmentsSafe(command) {
+    if (IS_WINDOWS) {
+      if (/;/.test(command) && command.split("|").length <= 1) return false;
+    } else {
+      if (/[;&]|&&|\|\|/.test(command)) return false;
+    }
+    const segments = command.split("|").map((s) => s.trim());
+    for (const segment of segments) {
+      const baseCommand = segment.split(/\s+/, 1)[0];
+      const commandName = IS_WINDOWS ? baseCommand.toLowerCase() : path3.basename(baseCommand);
+      if (!SAFE_COMMANDS.has(commandName)) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/agent.ts
+function getPersistencePath() {
+  const appData = process.env["APPDATA"] || (process.platform === "darwin" ? path4.join(os.homedir(), "Library", "Application Support") : path4.join(os.homedir(), ".local", "share"));
+  const dir = path4.join(appData, "prbe-agent");
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  return path4.join(dir, "agent-state.json");
+}
+function loadPersistedData() {
+  try {
+    const filePath = getPersistencePath();
+    if (fs2.existsSync(filePath)) {
+      const raw = fs2.readFileSync(filePath, "utf-8");
+      return JSON.parse(raw);
+    }
+  } catch {
+  }
+  return {};
+}
+function savePersistedData(data) {
+  try {
+    const filePath = getPersistencePath();
+    fs2.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+  } catch {
+    console.error("[PRBEAgent] Failed to save persisted data");
+  }
+}
+var PRBEAgent = class _PRBEAgent {
+  state;
+  logCapture;
+  config;
+  appDataPath;
+  interactionHandler;
+  registry = new PRBEToolRegistry();
+  grantedPaths = /* @__PURE__ */ new Set();
+  userCancelled = false;
+  activeWS = null;
+  pollingTimer = null;
+  persistedData;
+  fetchAbortController = null;
+  currentInvestigationSource = "user" /* 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 = randomUUID5();
+    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,
+      autoApprovedDirs: config.autoApprovedDirs,
+      pollingInterval: config.pollingInterval ?? 6e5,
+      maxLogEntries: config.maxLogEntries ?? 1e4,
+      captureConsole: config.captureConsole ?? true,
+      backgroundPolling: config.backgroundPolling ?? true
+    };
+    this.interactionHandler = config.interactionHandler;
+    this.appDataPath = config.appDataPath;
+    if (this.appDataPath && !this.config.autoApprovedDirs.includes(this.appDataPath)) {
+      this.config.autoApprovedDirs.push(this.appDataPath);
+    }
+    this.state = new PRBEAgentState();
+    this.logCapture = new PRBELogCapture(this.config.maxLogEntries);
+    this.persistedData = loadPersistedData();
+    const roots = this.config.autoApprovedDirs;
+    const requester = this.interactionHandler ? this : void 0;
+    const grantedPaths = this.grantedPaths;
+    this.registry.register(new ListDirectoryTool(roots, requester, grantedPaths));
+    this.registry.register(new ReadFileTool(roots, requester, grantedPaths));
+    this.registry.register(new SearchContentTool(roots, requester, grantedPaths));
+    this.registry.register(new FindFilesTool(roots, requester, grantedPaths));
+    this.registry.register(
+      new FlagFileTool(roots, (file) => {
+        this.pendingFlaggedFiles.push(file);
+      }, requester, grantedPaths)
+    );
+    this.registry.register(new ReadAppLogsTool(this.logCapture));
+    this.registry.register(new SearchAppLogsTool(this.logCapture));
+    this.registry.register(new ClearAppLogsTool(this.logCapture));
+    this.registry.register(
+      new FlagAppLogsTool(this.logCapture, (file) => {
+        this.pendingFlaggedFiles.push(file);
+      })
+    );
+    if (requester) {
+      this.registry.register(new AskUserTool(requester));
+      this.registry.register(new BashExecuteTool(requester, roots, grantedPaths));
+    }
+    if (this.config.captureConsole) {
+      this.logCapture.startCapturing();
+    }
+    if (config.electronLog) {
+      this.hookElectronLog(config.electronLog);
+    }
+    if (config.ipcMain) {
+      this.hookRendererLogs(config.ipcMain, config.rendererLogChannel ?? "prbe-renderer-log");
+    }
+    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 {
+          }
+          return message;
+        }
+      );
+    } catch {
+    }
+  }
+  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 PRBEAgentError(
+        "server_error" /* SERVER_ERROR */,
+        "No interaction handler configured"
+      );
+    }
+    if (this.currentInvestigationSource === "context_request" /* CONTEXT_REQUEST */ && this.currentCRId) {
+      this.state.setCRPendingInteraction(this.currentCRId, payload);
+    } else {
+      this.state.setPendingInteraction(payload);
+    }
+    try {
+      const response = await this.interactionHandler.handleInteraction(payload);
+      if (this.currentInvestigationSource === "context_request" /* CONTEXT_REQUEST */ && this.currentCRId) {
+        this.state.resolveCRInteraction(this.currentCRId, response);
+      } else {
+        this.state.resolveInteraction(response);
+      }
+      return response;
+    } catch (err) {
+      if (this.currentInvestigationSource === "context_request" /* CONTEXT_REQUEST */ && this.currentCRId) {
+        this.state.clearCRPendingInteraction(this.currentCRId);
+      } else {
+        this.state.clearPendingInteraction();
+      }
+      throw err;
+    }
+  }
+  /**
+   * Add an additional root directory to the runtime allowed roots.
+   */
+  addAutoApprovedDir(rootPath) {
+    if (!this.config.autoApprovedDirs.includes(rootPath)) {
+      this.config.autoApprovedDirs.push(rootPath);
+    }
+  }
+  // ---------- Public API ----------
+  /**
+   * Register a custom tool that the middleware can invoke during investigations.
+   */
+  registerTool(name, description, parameters, handler) {
+    this.registry.register(
+      new PRBEClosureTool(name, description, parameters, handler)
+    );
+  }
+  /**
+   * User-initiated investigation. Updates `state` events/report directly.
+   */
+  async investigate(query, contextRequestID) {
+    this.userCancelled = false;
+    this.currentInvestigationSource = "user" /* USER */;
+    this.currentCRId = null;
+    this.state.beginInvestigation(query);
+    const emitter = (status) => {
+      switch (status.type) {
+        case "started" /* STARTED */:
+          this.state.appendEvent("Starting investigation...");
+          break;
+        case "thinking" /* THINKING */:
+          break;
+        case "tool_call" /* TOOL_CALL */:
+          this.state.appendEvent(status.label);
+          break;
+        case "observation" /* OBSERVATION */:
+          this.state.attachObservation(status.text);
+          break;
+        case "thought" /* THOUGHT */:
+          this.state.appendEvent("Thinking", status.text);
+          break;
+        case "completed" /* COMPLETED */:
+          this.state.completeInvestigation(status.report, status.userSummary);
+          break;
+        case "error" /* ERROR */:
+          this.state.failInvestigation(status.message);
+          break;
+      }
+    };
+    const result = await this.connectToProxy(
+      query,
+      contextRequestID,
+      emitter,
+      () => this.userCancelled
+    );
+    this.currentInvestigationSource = "user" /* USER */;
+    this.currentCRId = null;
+    if (result?.ticketId) {
+      this.addTrackedTicket(result.ticketId);
+    } else if (!result) {
+      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(1e3, "User cancelled");
+      this.activeWS = null;
+    }
+  }
+  /**
+   * Cancel everything — user investigation and polling.
+   */
+  cancel() {
+    this.userCancelled = true;
+    if (this.activeWS) {
+      this.activeWS.close(1e3, "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
+      );
+      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)
+        );
+      }
+      const knownCRIDs = /* @__PURE__ */ 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);
+          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;
+        }
+      }
+      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("status" /* STATUS */);
+  }
+  /**
+   * Delete the persisted data file. Can be called without an agent instance.
+   */
+  static clearPersistedData() {
+    try {
+      const filePath = getPersistencePath();
+      if (fs2.existsSync(filePath)) {
+        fs2.unlinkSync(filePath);
+      }
+    } catch {
+    }
+  }
+  // ---------- CR Investigation ----------
+  async investigateForCR(cr, ticketId) {
+    const crID = cr.id;
+    this.currentInvestigationSource = "context_request" /* CONTEXT_REQUEST */;
+    this.currentCRId = crID;
+    this.state.beginCR(crID, cr.query, cr.slug ?? void 0);
+    const emitter = (status) => {
+      switch (status.type) {
+        case "started" /* STARTED */:
+          this.state.appendCREvent(crID, "Starting investigation...");
+          break;
+        case "thinking" /* THINKING */:
+          break;
+        case "tool_call" /* TOOL_CALL */:
+          this.state.appendCREvent(crID, status.label);
+          break;
+        case "observation" /* OBSERVATION */:
+          this.state.attachCRObservation(crID, status.text);
+          break;
+        case "thought" /* THOUGHT */:
+          this.state.appendCREvent(crID, "Thinking", status.text);
+          break;
+        case "completed" /* COMPLETED */:
+          this.state.completeCR(crID, status.report, status.userSummary);
+          break;
+        case "error" /* 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 = "user" /* USER */;
+    this.currentCRId = null;
+    if (result?.ticketId) {
+      this.addTrackedTicket(result.ticketId);
+    }
+  }
+  // ---------- WebSocket Investigation ----------
+  connectToProxy(query, contextRequestID, emit, isCancelled, ticketId) {
+    return new Promise((resolve2) => {
+      const wsUrl = `${MIDDLEWARE_URL}/api/agent/client/ws`;
+      let ws;
+      try {
+        ws = new WebSocket(wsUrl, {
+          headers: {
+            "X-API-Key": this.config.apiKey
+          }
+        });
+      } catch (err) {
+        emit({
+          type: "error" /* ERROR */,
+          message: `Failed to create WebSocket: ${err}`
+        });
+        resolve2(null);
+        return;
+      }
+      this.activeWS = ws;
+      let uploadBaseUrl;
+      let resolved = false;
+      const finish = (result) => {
+        if (resolved) return;
+        resolved = true;
+        this.activeWS = null;
+        resolve2(result);
+      };
+      ws.onopen = () => {
+        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
+          })),
+          ...decl.interactive ? { interactive: true } : {}
+        }));
+        const startMetadata = {
+          agent_id: this.agentID,
+          custom_tools: toolDeclarations
+        };
+        if (contextRequestID) {
+          startMetadata["context_request_id"] = contextRequestID;
+        }
+        if (ticketId) {
+          startMetadata["ticket_id"] = ticketId;
+        }
+        if (this.appDataPath) {
+          startMetadata["app_data_path"] = this.appDataPath;
+        }
+        const startMsg = {
+          type: "start" /* START */,
+          content: query,
+          metadata: startMetadata
+        };
+        try {
+          ws.send(JSON.stringify(startMsg));
+        } catch (err) {
+          emit({
+            type: "error" /* ERROR */,
+            message: `Failed to send start message: ${err}`
+          });
+          finish(null);
+          return;
+        }
+        emit({ type: "started" /* STARTED */ });
+        this.pendingFlaggedFiles = [];
+      };
+      ws.onmessage = async (event) => {
+        if (isCancelled()) {
+          this.sendCancel(ws);
+          ws.close(1e3, "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 "thought" /* THOUGHT */:
+            emit({
+              type: "thought" /* THOUGHT */,
+              text: msg.content ?? ""
+            });
+            break;
+          case "tool_call" /* TOOL_CALL */: {
+            const toolName = msg.name ?? "";
+            const callId = msg.id ?? "";
+            const args = this.extractArgs(msg.metadata);
+            emit({
+              type: "tool_call" /* TOOL_CALL */,
+              name: toolName,
+              label: msg.content ?? `Running ${toolName}`
+            });
+            this.pendingFlaggedFiles = [];
+            const toolResult = redactPII(
+              await this.registry.execute(toolName, args)
+            );
+            emit({
+              type: "observation" /* OBSERVATION */,
+              text: toolResult.substring(0, 200)
+            });
+            let resultMetadata;
+            if (this.pendingFlaggedFiles.length > 0 && uploadBaseUrl) {
+              const uploadPrefix = this.extractUploadPrefix(uploadBaseUrl);
+              const uploadedRefs = [];
+              for (const file of this.pendingFlaggedFiles) {
+                const filename = path4.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
+                });
+                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: "tool_result" /* TOOL_RESULT */,
+              id: callId,
+              name: toolName,
+              content: toolResult,
+              metadata: resultMetadata
+            };
+            try {
+              ws.send(JSON.stringify(resultMsg));
+            } catch {
+            }
+            break;
+          }
+          case "server_tool_call" /* SERVER_TOOL_CALL */:
+            emit({
+              type: "tool_call" /* TOOL_CALL */,
+              name: msg.name ?? "",
+              label: msg.content ?? ""
+            });
+            break;
+          case "server_observation" /* SERVER_OBSERVATION */:
+            emit({
+              type: "observation" /* OBSERVATION */,
+              text: (msg.content ?? "").substring(0, 200)
+            });
+            break;
+          case "complete" /* COMPLETE */: {
+            const report = msg.content ?? "";
+            const userSummary = msg.metadata?.["user_summary"] ?? "";
+            const ticketId2 = msg.metadata?.["ticket_id"];
+            emit({
+              type: "completed" /* COMPLETED */,
+              report,
+              userSummary
+            });
+            ws.close(1e3, "Complete");
+            finish({ report, userSummary, ticketId: ticketId2 });
+            break;
+          }
+          case "error" /* ERROR */:
+            emit({
+              type: "error" /* ERROR */,
+              message: msg.content || "Unknown error"
+            });
+            ws.close(1e3, "Error received");
+            finish(null);
+            break;
+          case "session_config" /* SESSION_CONFIG */:
+            uploadBaseUrl = msg.metadata?.["upload_url"];
+            break;
+          case "ping" /* PING */: {
+            const pongMsg = { type: "pong" /* PONG */ };
+            try {
+              ws.send(JSON.stringify(pongMsg));
+            } catch {
+            }
+            break;
+          }
+          // SDK-originated types and upload_url — ignore
+          case "start" /* START */:
+          case "tool_result" /* TOOL_RESULT */:
+          case "upload_request" /* UPLOAD_REQUEST */:
+          case "cancel" /* CANCEL */:
+          case "pong" /* PONG */:
+          case "upload_url" /* UPLOAD_URL */:
+            break;
+        }
+      };
+      ws.onerror = (event) => {
+        if (isCancelled()) {
+          finish(null);
+          return;
+        }
+        const errorEvent = event;
+        const message = errorEvent.message || "WebSocket connection error";
+        emit({ type: "error" /* ERROR */, message });
+        finish(null);
+      };
+      ws.onclose = (_event) => {
+        if (!resolved) {
+          if (isCancelled()) {
+            finish(null);
+          } else {
+            emit({
+              type: "error" /* ERROR */,
+              message: "WebSocket connection closed unexpectedly"
+            });
+            finish(null);
+          }
+        }
+      };
+    });
+  }
+  sendCancel(ws) {
+    try {
+      const cancelMsg = { type: "cancel" /* CANCEL */ };
+      ws.send(JSON.stringify(cancelMsg));
+    } catch {
+    }
+  }
+  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;
+      const marker = "/api/agent/upload/";
+      const idx = urlPath.indexOf(marker);
+      if (idx !== -1) {
+        return urlPath.substring(idx + marker.length);
+      }
+    } catch {
+    }
+    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 = `${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 PRBEAgentError(
+        "server_error" /* SERVER_ERROR */,
+        `Server error ${response.status}: ${message}`,
+        response.status
+      );
+    }
+    return await response.json();
+  }
+};
+
+// src/serialization.ts
+var DEFAULT_PRBE_STATE = {
+  isInvestigating: false,
+  events: [],
+  report: "",
+  summary: "",
+  currentQuery: "",
+  resolvedInteractions: [],
+  completedInvestigations: [],
+  activeCRs: [],
+  completedCRs: [],
+  trackedTicketIDs: [],
+  ticketInfo: [],
+  hasActiveWork: false
+};
+function serializeCR(cr) {
+  return {
+    id: cr.id,
+    query: cr.query,
+    slug: cr.slug,
+    events: cr.events,
+    isRunning: cr.isRunning,
+    isCompleted: cr.isCompleted,
+    isFailed: cr.isFailed,
+    report: cr.report,
+    summary: cr.summary,
+    errorMessage: cr.errorMessage,
+    startedAt: cr.startedAt.toISOString(),
+    pendingInteraction: cr.pendingInteraction,
+    resolvedInteractions: cr.resolvedInteractions ?? []
+  };
+}
+function serializePRBEState(state) {
+  return {
+    isInvestigating: state.isInvestigating,
+    events: state.events,
+    report: state.report,
+    summary: state.summary,
+    currentQuery: state.currentQuery,
+    investigationError: state.investigationError,
+    pendingInteraction: state.pendingInteraction,
+    resolvedInteractions: state.resolvedInteractions,
+    completedInvestigations: state.completedInvestigations.map((inv) => ({
+      id: inv.id,
+      query: inv.query,
+      report: inv.report,
+      summary: inv.summary,
+      completedAt: inv.completedAt.toISOString()
+    })),
+    activeCRs: Array.from(state.activeCRs.values()).map(serializeCR),
+    completedCRs: state.completedCRs.map(serializeCR),
+    trackedTicketIDs: state.trackedTicketIDs,
+    ticketInfo: state.ticketInfo,
+    hasActiveWork: state.hasActiveWork
+  };
+}
+
+// src/assets/index.ts
+var PROBE_MARK_SVG = `<svg width="256" height="256" viewBox="0 0 256 256" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M50 112 L114 148 L50 184 Z" fill="#111111" opacity="0.07"/>
+  <path d="M70 86 L148 134 L70 182 Z" fill="#111111" opacity="0.18"/>
+  <path d="M92 56 L192 118 L92 180 Z" fill="#111111"/>
+</svg>`;
+export {
+  API_URL,
+  AskUserTool,
+  BashExecuteTool,
+  ClearAppLogsTool,
+  DEFAULT_PRBE_STATE,
+  FindFilesTool,
+  FlagAppLogsTool,
+  FlagFileTool,
+  InteractionType,
+  InvestigationSource,
+  ListDirectoryTool,
+  MIDDLEWARE_URL,
+  PRBEAgent,
+  PRBEAgentConfigKey,
+  PRBEAgentError,
+  PRBEAgentErrorType,
+  PRBEAgentState,
+  PRBEAgentStatusType,
+  PRBEClosureTool,
+  PRBELogCapture,
+  PRBEStateEvent,
+  PRBEToolRegistry,
+  PROBE_MARK_SVG,
+  ReadAppLogsTool,
+  ReadFileTool,
+  SearchAppLogsTool,
+  SearchContentTool,
+  ToolName,
+  ToolParamType,
+  WSMessageType,
+  humanReadableSize,
+  redactPII,
+  resolveAndValidate,
+  resolveWithAccessRequest,
+  serializePRBEState
+};
+//# sourceMappingURL=index.mjs.map