main.js

// Darknode desktop - Electron main process. Runs shell commands (streamed),
// checks installed tools, and proxies local Ollama. Renderer has no Node access
// (contextIsolation) and talks only through the preload bridge.
const { app, BrowserWindow, ipcMain, shell, dialog, safeStorage, screen, session } = require("electron");
const { spawn, execFile } = require("child_process");
const os = require("os");
const path = require("path");
const http = require("http");
const https = require("https");
const net = require("net");
const tls = require("tls");
const dns = require("dns").promises;
const fs = require("fs");
const { fileURLToPath } = require("url");
// AI + enterprise governance (vendored from the Darknode CLI)
const { toAnthropicBody, anthropicDelta, usageOf } = require("./lib/anthropic");
const { resolveOperator } = require("./lib/identity");
const { appendUsage, loadUsage, summarize, renderReport } = require("./lib/usage");
const { buildBundle, verifyBundle, renderBundleMd } = require("./lib/compliance");
const hardeningAudit = require("./lib/hardening-audit");
const toolkit = require("./lib/toolkit");
const { scanPorts } = require("./lib/recon/portscan");
const { fuzzDirs } = require("./lib/recon/fuzz");
const cveLib = require("./lib/cve");
const { safeFetch } = require("./lib/net/guard");
const { ScopeEnforcer } = require("./lib/scope/enforce");
const redactor = require("./lib/secret/redact");
const { createVault, electronBackend } = require("./lib/secret/vault");
const webshell = require("./lib/webshell/origin");
const { createHandler: createWebHandler } = require("./lib/webshell/serve");
const { runGoogleSignIn } = require("./lib/webshell/google-signin");

// DA-008: redact secrets from the main-process log channel. Any value the vault
// holds is registered with the redactor, so even an unusual token is scrubbed
// here. Shape rules catch the rest. Installed before anything logs.
(function installRedactingConsole() {
  for (const level of ["log", "info", "warn", "error", "debug"]) {
    const orig = console[level] ? console[level].bind(console) : null;
    if (!orig) continue;
    console[level] = (...args) => orig(...args.map((a) => {
      try { return typeof a === "string" ? redactor.redactString(a) : redactor.redact(a); } catch (_) { return a; }
    }));
  }
})();

// Keep a stray throw/rejection from a PTY, QEMU or streaming socket from taking
// down the whole main process and silently losing all in-flight work. The
// console above redacts, so logging here can't leak a secret.
process.on("uncaughtException", (e) => console.error("[darknode] uncaught exception:", e));
process.on("unhandledRejection", (e) => console.error("[darknode] unhandled rejection:", e));

const RESULTS_DIR = path.join(os.homedir(), "darknode-results");

let nodePty = null;
try { nodePty = require("node-pty"); } catch (e) { console.error("[darknode] node-pty unavailable:", e.message); }
console.log("[darknode] node-pty:", nodePty ? "loaded" : "unavailable");

const isWin = process.platform === "win32";
let win;
const procs = new Map();
const ptys = new Map();
let ptySeq = 0;
let _zoom = 0; // persisted UI zoom level (webContents.setZoomLevel units)
let _quitting = false;
let _forceClose = false; // set once the user has confirmed closing with work in flight
let _agentExec = 0; // in-flight agent:exec tool commands (no shared map, so counted)

// Any in-flight work the user would lose by quitting: a running command, an AI
// stream, or an agent tool command. An open terminal shell (in `ptys`) is expected
// and deliberately does not count. Used to confirm-before-close.
function workInFlight() {
  return procs.size > 0 || streamReqs.size > 0 || claudeReqs.size > 0 || apiReqs.size > 0 || daiReqs.size > 0 || _agentExec > 0;
}

// --- window state (QoL): remember size/position/maximized/zoom across launches ---
// A tiny JSON file in userData, written debounced on resize/move and on close.
const winStatePath = () => path.join(govCwd(), "window-state.json");
function loadWinState() {
  try { const s = JSON.parse(fs.readFileSync(winStatePath(), "utf8")); return (s && typeof s === "object") ? s : {}; } catch (_) { return {}; }
}
let _saveT = null;
function saveWinState() {
  if (!win || win.isDestroyed()) return;
  try {
    const b = win.getNormalBounds ? win.getNormalBounds() : win.getBounds(); // un-maximized bounds, so restore returns to the real size
    fs.mkdirSync(path.dirname(winStatePath()), { recursive: true });
    fs.writeFileSync(winStatePath(), JSON.stringify({ width: b.width, height: b.height, x: b.x, y: b.y, maximized: win.isMaximized(), zoom: _zoom }));
  } catch (_) {}
}
function saveWinStateSoon() { clearTimeout(_saveT); _saveT = setTimeout(saveWinState, 400); }
// A saved position is only reused if it still lands on a connected display, so a
// window never restores off-screen after a monitor is unplugged.
function onScreen(x, y, w, h) {
  try {
    const a = screen.getDisplayMatching({ x, y, width: w, height: h }).workArea;
    return x + w > a.x + 40 && y + h > a.y + 40 && x < a.x + a.width - 40 && y < a.y + a.height - 40;
  } catch (_) { return false; }
}

// ---- Shell selection (D0) ----
// Default: the packaged website (web/, produced by scripts/sync-web.mjs) served on
// the fixed app origin. DARKNODE_CLASSIC=1 keeps the legacy renderer reachable
// until it is retired in D2; a missing web/ bundle also falls back to it.
const WEB_ROOT = path.join(__dirname, "web");
const CLASSIC_FILE = path.join(__dirname, "renderer", "index.html");
const SHELL = (process.env.DARKNODE_CLASSIC === "1" || !fs.existsSync(path.join(WEB_ROOT, "index.html"))) ? "classic" : "web";
if (SHELL === "classic" && process.env.DARKNODE_CLASSIC !== "1") console.warn("[darknode] web/ bundle missing - run `npm run sync-web`; using the classic renderer");
const IPC_CTX = SHELL === "web"
  ? { mode: "web", appOrigin: webshell.APP_ORIGIN }
  : { mode: "classic", classicFileUrl: require("url").pathToFileURL(CLASSIC_FILE).href };
// Capabilities the web shell really exposes (window.darknode.desktop.caps).
const WEB_CAPS = ["auth.google", "openExternal", "titlebar", "offline", "native", "device", "update"];
const WEB_PARTITION = "persist:darknode";
// The native tools window (web shell only) runs the app's own bundled classic
// renderer, never website content, so it keeps the full classic surface.
const CLASSIC_CTX = { mode: "classic", classicFileUrl: require("url").pathToFileURL(CLASSIC_FILE).href };
const ctxFor = (frame) => (SHELL === "web" && frame && webshell.isClassicUrl(frame.url, CLASSIC_CTX.classicFileUrl) ? CLASSIC_CTX : IPC_CTX);

// The web origin must be a privileged, secure, service-worker-capable origin.
// http://localhost already is (potentially trustworthy), so nothing is registered
// for it; the session below intercepts it instead of opening a socket.

// Every IPC handler is wrapped: the caller must be the top-level frame of the
// trusted shell (app origin, or the classic file) and the channel must be one
// that shell may use. A navigated, compromised or embedded frame is refused.
{
  const rawHandle = ipcMain.handle.bind(ipcMain);
  ipcMain.handle = (channel, fn) => rawHandle(channel, (event, ...args) => {
    let frame = null;
    try { const f = event.senderFrame; if (f) frame = { url: f.url, isTop: !f.parent }; } catch (_) {}
    const ctx = ctxFor(frame);
    if (!webshell.isTrustedSender(frame, ctx) || !webshell.channelAllowed(channel, ctx)) {
      let from = "(no frame)"; try { from = frame ? new URL(frame.url).origin : from; } catch (_) {}
      console.warn("[darknode] refused IPC " + channel + " from " + from);
      throw new Error("IPC refused");
    }
    return fn(event, ...args);
  });
}

// Wire the app session: serve web/ for the app origin, pass every other http
// request through untouched, serve the vendored Firebase SDK locally, and deny
// permission prompts the website does not need.
function setupWebSession() {
  const ses = session.fromPartition(WEB_PARTITION);
  let hosting = {};
  try { hosting = JSON.parse(fs.readFileSync(path.join(WEB_ROOT, ".hosting.json"), "utf8")); } catch (e) { console.warn("[darknode] web/.hosting.json unreadable; serving without hosting headers:", e.message); }
  // The site imports the Firebase SDK from www.gstatic.com. When sync-web vendored
  // that exact version, every reference in served JS/HTML is pointed at the local
  // copy, so the console boots offline. All references are rewritten together
  // (pages and the SDK's own cross-imports), so there is one SDK instance.
  const vendorDir = path.join(WEB_ROOT, "__vendor");
  const GSTATIC = "https://www.gstatic.com/firebasejs/";
  const vendored = new Set();
  try { for (const v of fs.readdirSync(path.join(vendorDir, "www.gstatic.com", "firebasejs"))) vendored.add(v); } catch (_) {}
  const GSTATIC_RE = /https:\/\/www\.gstatic\.com\/firebasejs\/(\d+\.\d+\.\d+)\//g;
  const serveWeb = createWebHandler({
    root: WEB_ROOT, hosting,
    transform: (p, buf) => {
      if (!vendored.size || !/\.(m?js|html)$/.test(p)) return null;
      const text = buf.toString("utf8");
      if (!text.includes(GSTATIC)) return null;
      return Buffer.from(text.replace(GSTATIC_RE, (m, ver) => (vendored.has(ver) ? "/__vendor/www.gstatic.com/firebasejs/" + ver + "/" : m)), "utf8");
    },
  });
  ses.protocol.handle("http", (req) => {
    let host = ""; try { host = new URL(req.url).host; } catch (_) {}
    if (host === webshell.APP_HOST) return serveWeb(req);
    return ses.fetch(req, { bypassCustomProtocolHandlers: true });
  });
  const ALLOWED_PERMS = new Set(["clipboard-read", "clipboard-sanitized-write", "fullscreen"]);
  ses.setPermissionRequestHandler((wc, permission, cb, details) => {
    cb(ALLOWED_PERMS.has(permission) && webshell.isAppUrl((details && details.requestingUrl) || wc.getURL()));
  });
  return ses;
}

// The window that hosts the native (classic) UI: the main window in classic mode,
// the native tools window in web mode. Streamed output (terminals, scans, AI tokens)
// goes there.
let nativeWin = null;
const uiWin = () => (SHELL === "web" ? nativeWin : win);
function toUi(channel, payload) {
  const w = uiWin();
  if (w && !w.isDestroyed()) { try { w.webContents.send(channel, payload); } catch (_) {} }
}
const NATIVE_SECTIONS = new Set(["runner", "scanner", "fuzzer", "recon", "vms", "lab", "forensics", "loot", "tools", "payloads", "exploits", "http", "engagement", "playbooks", "wordlists", "cloud", "github", "agent", "home"]);
function reapNativeWork() {
  for (const p of procs.values()) { try { p.kill(); } catch (_) {} } procs.clear();
  for (const p of ptys.values()) { try { p.kill(); } catch (_) {} } ptys.clear();
}
// Web shell: open (or focus) the native tools window, optionally on one section.
function openNativeWindow(sec, type) {
  if (nativeWin && !nativeWin.isDestroyed()) {
    // Still loading from an earlier open: the page has no listener yet, so send it after load.
    if (sec) { const go = () => toUi("native:go", { sec, type }); if (nativeWin.webContents.isLoading()) nativeWin.webContents.once("did-finish-load", () => setTimeout(go, 400)); else go(); }
    if (nativeWin.isMinimized()) nativeWin.restore();
    nativeWin.focus();
    return;
  }
  let force = false;
  nativeWin = new BrowserWindow({
    width: 1240, height: 820, minWidth: 900, minHeight: 600,
    backgroundColor: "#06080f", show: false, frame: false, title: "Darknode native tools",
    icon: path.join(__dirname, "renderer", "icon.png"),
    webPreferences: {
      preload: path.join(__dirname, "preload.js"),
      contextIsolation: true, nodeIntegration: false, sandbox: true, webviewTag: true,
      additionalArguments: ["--no-boot-anim"],
    },
  });
  const nw = nativeWin;
  nw.setMenuBarVisibility(false);
  nw.once("ready-to-show", () => nw.show());
  const rendererDir = path.join(__dirname, "renderer");
  nw.webContents.on("will-navigate", (e, url) => {
    let ok = false;
    try { const p = fileURLToPath(url); ok = p === path.join(rendererDir, "index.html") || p.startsWith(rendererDir + path.sep); } catch (_) {}
    if (!ok) e.preventDefault();
  });
  nw.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
  // Same confirm-before-close as the classic app while its work is in flight.
  nw.on("close", (e) => {
    if (force || _forceClose || !workInFlight()) return;
    e.preventDefault();
    toUi("app:confirm-close");
  });
  nw.on("maximize", () => toUi("win:state", true));
  nw.on("unmaximize", () => toUi("win:state", false));
  nw.webContents.on("render-process-gone", reapNativeWork);
  nw.on("closed", () => { if (nativeWin === nw) nativeWin = null; reapNativeWork(); });
  nw._dnForceClose = () => { force = true; nw.close(); };
  // A command to type (not run) goes over once the page is up; the hash alone opens the section.
  if (type) nw.webContents.once("did-finish-load", () => setTimeout(() => toUi("native:go", { sec, type }), 400));
  nw.loadFile(CLASSIC_FILE, sec && !type ? { hash: "sec=" + sec } : undefined);
}

function windowFrameOptions() {
  if (SHELL === "classic") return { frame: false };
  // Native window controls; the website draws its own top bar beneath them and
  // marks it as the drag region (html[data-desktop] in the web CSS).
  if (process.platform === "darwin") return { titleBarStyle: "hiddenInset" };
  return { titleBarStyle: "hidden", titleBarOverlay: { color: "#ffffff", symbolColor: "#1f2937", height: 48 } };
}

function createWindow() {
  const st = loadWinState();
  _zoom = Number.isFinite(st.zoom) ? st.zoom : 0;
  const webPreferences = {
    preload: path.join(__dirname, "preload.js"),
    contextIsolation: true,
    nodeIntegration: false,
    sandbox: true,      // OS-level sandbox for the renderer/preload (defense in depth)
    webSecurity: true,
    webviewTag: SHELL === "classic",   // the classic Browser section (<webview>) only
  };
  if (SHELL === "web") {
    webPreferences.session = setupWebSession();
    webPreferences.additionalArguments = ["--dn-shell=web", "--dn-app-origin=" + webshell.APP_ORIGIN, "--dn-app-version=" + app.getVersion(), "--dn-caps=" + WEB_CAPS.join(",")];
  }
  const opts = Object.assign({
    width: 1300, height: 840, minWidth: 900, minHeight: 600,
    backgroundColor: SHELL === "web" ? "#ffffff" : "#06080f",
    show: false,          // show on ready-to-show once painted, so there is no blank/flash on launch
    icon: path.join(__dirname, "renderer", "icon.png"),
    title: "Darknode",
    webPreferences,
  }, windowFrameOptions());
  if (Number.isFinite(st.width) && st.width >= opts.minWidth) opts.width = Math.round(st.width);
  if (Number.isFinite(st.height) && st.height >= opts.minHeight) opts.height = Math.round(st.height);
  if (Number.isFinite(st.x) && Number.isFinite(st.y) && onScreen(st.x, st.y, opts.width, opts.height)) { opts.x = Math.round(st.x); opts.y = Math.round(st.y); }
  win = new BrowserWindow(opts);
  win.setMenuBarVisibility(false);
  win.once("ready-to-show", () => { if (st.maximized) win.maximize(); win.show(); });
  win.on("resize", saveWinStateSoon);
  win.on("move", saveWinStateSoon);
  win.on("close", saveWinState);
  // Confirm before closing while a command / AI stream / agent run is in flight, so
  // a stray click on X does not silently kill in-progress work. The renderer shows
  // the confirm (no native dialog); on "close anyway" it calls win:close-now.
  win.on("close", (e) => {
    if (SHELL === "web") {
      if (!_forceClose && nativeWin && !nativeWin.isDestroyed()) {
        e.preventDefault();
        // Finish what the user asked for once the tools window is gone (it used to take a
        // second click, and Cmd+Q was dropped). With work in flight the tools window asks first.
        if (!workInFlight()) { const quitting = _quitting; nativeWin.once("closed", () => { if (quitting) app.quit(); else if (win && !win.isDestroyed()) win.close(); }); }
        nativeWin.focus(); nativeWin.close();
      }
      return;
    }
    if (_forceClose || !workInFlight()) return;
    e.preventDefault();
    try { win.webContents.send("app:confirm-close"); } catch (_) {}
  });
  // Standard zoom chords (Ctrl/Cmd +/-/0), handled here because the menu bar is
  // hidden so the default zoom roles never register. Persisted with window state.
  win.webContents.on("before-input-event", (e, input) => {
    if (input.type !== "keyDown" || !(input.control || input.meta)) return;
    const k = input.key, code = input.code;
    if (k === "=" || k === "+" || code === "NumpadAdd") { _zoom = Math.min(_zoom + 0.5, 5); win.webContents.setZoomLevel(_zoom); e.preventDefault(); saveWinStateSoon(); }
    else if (k === "-" || k === "_" || code === "NumpadSubtract") { _zoom = Math.max(_zoom - 0.5, -3); win.webContents.setZoomLevel(_zoom); e.preventDefault(); saveWinStateSoon(); }
    else if (k === "0" || code === "Numpad0") { _zoom = 0; win.webContents.setZoomLevel(0); e.preventDefault(); saveWinStateSoon(); }
  });
  win.webContents.on("did-finish-load", () => { try { win.webContents.setZoomLevel(_zoom); } catch (_) {} });
  // If the renderer process dies (crash/OOM), the shells, streamed runs and MCP stdio
  // servers it owned are orphaned — and MCP would keep trying to reconnect to a dead
  // renderer every few seconds. Reap them so nothing leaks; VMs are left running (main
  // still holds their handles and a reloaded renderer can re-list them).
  win.webContents.on("render-process-gone", () => {
    if (SHELL === "web") return; // native work belongs to the native tools window
    for (const p of procs.values()) { try { p.kill(); } catch (_) {} } procs.clear();
    for (const p of ptys.values()) { try { p.kill(); } catch (_) {} } ptys.clear();
    for (const s of mcpServers.values()) { s.closedByUser = true; if (s.reconnectTimer) { try { clearTimeout(s.reconnectTimer); } catch (_) {} s.reconnectTimer = null; } try { if (s.proc) s.proc.kill("SIGKILL"); } catch (_) {} }
    mcpServers.clear(); mcpRetry.clear();
  });
  win.on("maximize", () => { win.webContents.send("win:state", true); saveWinStateSoon(); });
  win.on("unmaximize", () => { win.webContents.send("win:state", false); saveWinStateSoon(); });
  if (process.env.DARKNODE_DEBUG) win.webContents.on("console-message", (e, lvl, msg) => console.log("[renderer]", msg !== undefined ? msg : (e && e.message) || ""));
  if (process.env.DARKNODE_SHOT) win.webContents.on("did-finish-load", () => setTimeout(async () => { try { const img = await win.webContents.capturePage(); fs.writeFileSync(process.env.DARKNODE_SHOT, img.toPNG()); console.log("SHOT_SAVED"); } catch (e) { console.log("SHOT_ERR " + e.message); } }, Number(process.env.DARKNODE_SHOT_DELAY) || 3500));
  if (SHELL === "web") {
    // Security: the main frame stays on the app origin; real web links open in the
    // OS browser; every other scheme is dropped.
    const guardNav = (e, url) => {
      const kind = webshell.classifyNavigation(url);
      if (kind === "allow") return;
      e.preventDefault();
      if (kind === "external") shell.openExternal(url);
    };
    win.webContents.on("will-navigate", guardNav);
    win.webContents.on("will-redirect", (e, url, _inPlace, isMainFrame) => { if (isMainFrame) guardNav(e, url); });
    // window.open: only the Firebase auth handler may open in-app, as a sandboxed
    // popup that can only move between the auth/provider hosts.
    win.webContents.setWindowOpenHandler(({ url }) => {
      const kind = webshell.classifyWindowOpen(url);
      if (kind === "auth-popup") {
        return { action: "allow", overrideBrowserWindowOptions: { width: 520, height: 680, parent: win, autoHideMenuBar: true, titleBarStyle: "default", titleBarOverlay: false, webPreferences: { contextIsolation: true, nodeIntegration: false, sandbox: true } } };
      }
      if (kind === "blank") {
        return { action: "allow", overrideBrowserWindowOptions: { width: 900, height: 1000, autoHideMenuBar: true, backgroundColor: "#ffffff", titleBarStyle: "default", titleBarOverlay: false, webPreferences: { contextIsolation: true, nodeIntegration: false, sandbox: true } } };
      }
      if (kind === "external") shell.openExternal(url);
      return { action: "deny" };
    });
    win.webContents.on("did-create-window", (child, details) => {
      // Auth popups may move between the provider hosts; a blank report window never
      // navigates (its links go to the OS browser). Neither gets the bridge (preload).
      const blank = webshell.classifyWindowOpen(details && details.url) === "blank";
      const guardPopup = (e, url) => {
        if (blank) { e.preventDefault(); if (webshell.classifyNavigation(url) === "external") shell.openExternal(url); return; }
        if (!webshell.authPopupNavAllowed(url)) { e.preventDefault(); }
      };
      child.webContents.on("will-navigate", guardPopup);
      child.webContents.on("will-redirect", guardPopup);
      child.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
    });
    // The site asks before unloading when a tool has typed input (beforeunload).
    // Electron would silently cancel the navigation (e.g. sign-out); show the same
    // leave-or-stay choice a browser shows instead.
    win.webContents.on("will-prevent-unload", (e) => {
      const choice = dialog.showMessageBoxSync(win, { type: "question", buttons: ["Leave", "Stay"], defaultId: 1, cancelId: 1, title: "Darknode", message: "Leave this page?", detail: "Changes you made may not be saved." });
      if (choice === 0) e.preventDefault();
    });
    win.loadURL(webshell.APP_ORIGIN + "/");
    return;
  }
  // Security: keep the main renderer pinned to the app's own bundled files.
  // Any non-file URL, or a file:// path outside renderer/, is blocked — so a
  // stray link can't escape the shell into file:///etc/passwd etc.
  const rendererDir = path.join(__dirname, "renderer");
  win.webContents.on("will-navigate", (e, url) => {
    let ok = false;
    try { const p = fileURLToPath(url); ok = p === path.join(rendererDir, "index.html") || p.startsWith(rendererDir + path.sep); } catch (_) {}
    if (!ok) e.preventDefault();
  });
  // Security: block new-window requests from the renderer (links should use openExternal).
  win.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
  win.loadFile(CLASSIC_FILE);
}

// Constrain any web content (esp. the <webview> Browser tab): open real links in the
// OS browser, deny every other window.open, and never let a guest webview gain Node.
app.on("web-contents-created", (_e, contents) => {
  contents.setWindowOpenHandler(({ url }) => {
    try { const p = new URL(url).protocol; if (p === "http:" || p === "https:") shell.openExternal(url); } catch (_) {}
    return { action: "deny" };
  });
  contents.on("will-attach-webview", (_evt, wp) => { delete wp.preload; wp.nodeIntegration = false; wp.contextIsolation = true; wp.sandbox = true; });
});
// One instance: a second launch focuses the first (two processes must not share
// the persistent web partition).
if (!app.requestSingleInstanceLock()) app.quit();
else app.on("second-instance", () => { if (win) { if (win.isMinimized()) win.restore(); win.focus(); } });
app.whenReady().then(createWindow);
app.on("window-all-closed", () => { if (process.platform !== "darwin") app.quit(); });
app.on("activate", () => { if (BrowserWindow.getAllWindows().length === 0) createWindow(); });

ipcMain.handle("sysinfo", () => ({
  platform: process.platform, arch: process.arch, hostname: os.hostname(),
  release: os.release(), cpus: os.cpus().length,
  mem: Math.round(os.totalmem() / 1e9) + " GB", home: os.homedir(),
  electron: process.versions.electron, node: process.versions.node, version: app.getVersion(),
}));

// Check GitHub Releases for a newer version (renderer CSP blocks external fetch, so do it here).
// One GitHub lookup an hour at most (unauthenticated API: 60 requests/hour per IP).
let _updCache = null, _updAt = 0, _updP = null;
ipcMain.handle("app:checkUpdate", async () => {
  if (_updCache && Date.now() - _updAt < 3600000) return _updCache;
  if (!_updP) _updP = checkUpdateNow().then((r) => { if (r.ok) { _updCache = r; _updAt = Date.now(); } return r; }).finally(() => { _updP = null; });
  return _updP;
});
async function checkUpdateNow() {
  const cmp = (a, b) => { const x = a.split(".").map(Number), y = b.split(".").map(Number); for (let i = 0; i < 3; i++) { if ((x[i] || 0) !== (y[i] || 0)) return (x[i] || 0) - (y[i] || 0); } return 0; };
  try {
    const cur = app.getVersion();
    const ctrl = new AbortController(); const to = setTimeout(() => ctrl.abort(), 15000);
    let r; try { r = await fetch("https://api.github.com/repos/Darknode-Official/darknode-app/releases/latest", { headers: { "User-Agent": "Darknode" }, signal: ctrl.signal }); } finally { clearTimeout(to); }
    if (!r.ok) return { ok: false };
    const d = await r.json();
    const vers = (d.assets || []).map((a) => (a.name.match(/(\d+\.\d+\.\d+)/) || [])[1]).filter(Boolean);
    // Also take the release tag itself (e.g. v1.2.3) so a release whose assets
    // aren't version-named — or aren't uploaded yet — still reports correctly.
    const tag = (String(d.tag_name || "").match(/(\d+\.\d+\.\d+)/) || [])[1];
    if (tag) vers.push(tag);
    vers.sort(cmp);
    const latest = vers.length ? vers[vers.length - 1] : cur;
    return { ok: true, current: cur, latest, update: cmp(latest, cur) > 0, url: "https://github.com/Darknode-Official/darknode-app/releases/latest" };
  } catch (e) { return { ok: false, error: e.message }; }
}

// ---- Native Gmail OAuth (Desktop client: loopback + PKCE) ----
// A Desktop OAuth client can't keep its secret confidential (it ships in the app),
// which is expected for installed apps; loopback + PKCE is the flow Google prescribes.
// The id/secret are NOT hardcoded here -- they load from env or oauth.config.json
// (gitignored), so no credentials live in source. See oauth.config.example.json.
function loadOAuthConfig() {
  try { const p = path.join(__dirname, "oauth.config.json"); if (fs.existsSync(p)) return JSON.parse(fs.readFileSync(p, "utf8")); } catch (_) {}
  return {};
}
const _oauthCfg = loadOAuthConfig();
const GMAIL_OAUTH = {
  clientId: process.env.DARKNODE_GMAIL_CLIENT_ID || _oauthCfg.gmailClientId || "",
  clientSecret: process.env.DARKNODE_GMAIL_CLIENT_SECRET || _oauthCfg.gmailClientSecret || "",
  scopes: ["https://www.googleapis.com/auth/gmail.readonly", "https://www.googleapis.com/auth/gmail.compose"],
};
const b64url = (buf) => buf.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
// Block loopback / link-local (incl. cloud metadata 169.254.169.254) / private
// ranges so net:get can't be turned into an SSRF/exfil channel by tool input.
// SSRF guard lives in lib/net/guard.js (isPrivateHost, resolvesToPrivate,
// validateUrl, safeFetch). safeFetch re-validates EVERY redirect hop so a
// permitted public host cannot 3xx-redirect the fetch to an internal address.
async function gmailExchange(params) {
  const r = await fetch("https://oauth2.googleapis.com/token", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(params).toString() });
  return r.json();
}
ipcMain.handle("gmail:oauth", async (_e, creds) => {
  const crypto = require("crypto");
  const clientId = (creds && creds.clientId) || GMAIL_OAUTH.clientId;
  const clientSecret = (creds && creds.clientSecret) || GMAIL_OAUTH.clientSecret;
  return await new Promise((resolve) => {
    const verifier = b64url(crypto.randomBytes(32));
    const challenge = b64url(crypto.createHash("sha256").update(verifier).digest());
    const state = b64url(crypto.randomBytes(16));
    let redirect = "", done = false;
    const finish = (v) => { if (done) return; done = true; try { server.close(); } catch (_) {} resolve(v); };
    const server = http.createServer(async (req, res) => {
      try {
        const u = new URL(req.url, redirect || "http://127.0.0.1");
        const code = u.searchParams.get("code"), err = u.searchParams.get("error");
        if (!code && !err) { res.writeHead(404); res.end(); return; }
        // CSRF defense-in-depth: reject callbacks whose state doesn't match ours.
        if (code && u.searchParams.get("state") !== state) { res.writeHead(400); res.end("bad state"); return; }
        res.writeHead(200, { "Content-Type": "text/html" });
        res.end("<!doctype html><meta charset=utf-8><body style='font-family:system-ui;background:#0b0e14;color:#e6edf3;text-align:center;padding-top:90px'><h2>" + (code ? "Gmail connected ✓" : "Gmail connection failed") + "</h2><p>You can close this tab and return to Darknode.</p>");
        if (err || !code) return finish({ ok: false, error: err || "no authorization code" });
        const d = await gmailExchange({ client_id: clientId, client_secret: clientSecret, code, code_verifier: verifier, grant_type: "authorization_code", redirect_uri: redirect });
        if (d.access_token) finish({ ok: true, access_token: d.access_token, refresh_token: d.refresh_token || "", expires_in: d.expires_in || 3600 });
        else finish({ ok: false, error: d.error_description || d.error || "token exchange failed" });
      } catch (e) { finish({ ok: false, error: e.message }); }
    });
    server.on("error", (e) => finish({ ok: false, error: e.message }));
    server.listen(0, "127.0.0.1", () => {
      redirect = "http://127.0.0.1:" + server.address().port;
      const auth = "https://accounts.google.com/o/oauth2/v2/auth?" + new URLSearchParams({ client_id: clientId, redirect_uri: redirect, response_type: "code", scope: GMAIL_OAUTH.scopes.join(" "), access_type: "offline", prompt: "consent", state, code_challenge: challenge, code_challenge_method: "S256" }).toString();
      shell.openExternal(auth);
    });
    setTimeout(() => finish({ ok: false, error: "timed out waiting for Google sign-in" }), 300000);
  });
});
ipcMain.handle("gmail:refresh", async (_e, arg) => {
  const refreshToken = typeof arg === "string" ? arg : (arg && arg.refreshToken);
  if (!refreshToken) return { ok: false, error: "no refresh token" };
  const clientId = (arg && arg.clientId) || GMAIL_OAUTH.clientId;
  const clientSecret = (arg && arg.clientSecret) || GMAIL_OAUTH.clientSecret;
  try {
    const d = await gmailExchange({ client_id: clientId, client_secret: clientSecret, refresh_token: refreshToken, grant_type: "refresh_token" });
    if (d.access_token) return { ok: true, access_token: d.access_token, expires_in: d.expires_in || 3600 };
    return { ok: false, error: d.error_description || d.error || "refresh failed" };
  } catch (e) { return { ok: false, error: e.message }; }
});

// Generic HTTP GET/POST proxy for the renderer — runs in the main process, so
// third-party security/OSINT APIs that don't send CORS headers still work.
// Returns { ok, status, data } (data is parsed JSON when the response is JSON).
ipcMain.handle("net:get", async (_e, opts) => {
  const { url, headers, method, body } = opts || {};
  try {
    if (!/^https?:\/\//i.test(String(url || ""))) return { ok: false, status: 0, error: "bad url" };
    const ctrl = new AbortController();
    const to = setTimeout(() => ctrl.abort(), 20000);
    try {
      // safeFetch validates the initial host AND every redirect hop (SSRF-safe).
      const r = await safeFetch(url, { method: method || "GET", headers: Object.assign({ "User-Agent": "Darknode/1.0" }, headers || {}), body: body || undefined, signal: ctrl.signal });
      const ct = r.headers.get("content-type") || "";
      // Cap the response body (like http:request does) so a huge/hostile reply
      // can't OOM the main process; parse JSON from the capped text ourselves.
      const text = await readTextCapped(r, 1_000_000);
      const data = ct.includes("json") ? (() => { try { return JSON.parse(text); } catch (_) { return null; } })() : text;
      return { ok: r.ok, status: r.status, data };
    } finally { clearTimeout(to); }
  } catch (e) { return { ok: false, status: 0, error: e.name === "AbortError" ? "timed out" : e.message }; }
});

// Stream a shell command's output to the renderer.
ipcMain.handle("run", (_e, { id, cmd, cwd }) => {
  const p = isWin ? spawn("cmd.exe", ["/c", cmd], { cwd: cwd || os.homedir() })
                  : spawn("/bin/sh", ["-c", cmd], { cwd: cwd || os.homedir() });
  procs.set(id, p);
  const send = (chunk) => toUi("run:data", { id, chunk });
  p.stdout.setEncoding("utf8"); p.stderr.setEncoding("utf8"); // decode across pipe-chunk boundaries so multibyte UTF-8 isn't split into U+FFFD
  p.stdout.on("data", send);
  p.stderr.on("data", send);
  p.on("close", (code) => { procs.delete(id); toUi("run:end", { id, code }); });
  p.on("error", (err) => { send("[error] " + err.message + "\n"); procs.delete(id); toUi("run:end", { id, code: -1 }); });
  return true;
});
ipcMain.handle("kill", (_e, id) => { const p = procs.get(id); if (p) { try { p.kill(); } catch (_) {} } return true; });

// ---- Agent: blocking command runner. Captures output + exit code (for the AI agent loop). ----
// Runs an agent command in a PTY so INTERACTIVE tools work fully autonomously:
// ssh, sudo, su, mysql -p, etc. all get a real terminal. We auto-answer the two prompts
// that otherwise block an unattended agent — the SSH host-key question ("yes") and
// password prompts (typed from the operator-configured `autopass`). Password input is not
// echoed by the tty, so it never lands in the captured output. Falls back to a plain pipe
// if node-pty is unavailable.
ipcMain.handle("agent:exec", (_e, { command, cwd, timeout, autopass }) => new Promise((res) => {
  _agentExec++;
  const workdir = cwd || os.homedir();
  const cap = 50000;
  let out = "", killed = false, settled = false, answers = 0, to;
  const finish = (v) => { if (settled) return; settled = true; _agentExec = Math.max(0, _agentExec - 1); clearTimeout(to); res(v); };
  // Strip ANSI/OSC escapes + stray control chars so the model sees clean text.
  const clean = (s) => s
    .replace(/\x1B\][\s\S]*?(?:\x07|\x1B\\)/g, "")
    .replace(/\x1B[\[\]][0-9;?=]*[ -\/]*[@-~]/g, "")
    .replace(/\x1B[()][0-9A-Za-z]/g, "")
    .replace(/\x1B[=>NM]/g, "")
    .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "")
    .replace(/\r\n?/g, "\n");
  if (!isWin && nodePty) {
    let p;
    try { p = nodePty.spawn("/bin/sh", ["-c", command], { name: "xterm-256color", cols: 120, rows: 40, cwd: workdir, env: process.env }); }
    catch (err) { return finish({ ok: false, error: err.message }); }
    p.onData((d) => {
      if (out.length < cap + 8000) out += d;
      const tail = out.slice(-240);
      if (answers < 10) {
        if (/(?:\(yes\/no(?:\/\[fingerprint\])?\)\??|continue connecting\??)\s*$/i.test(tail)) { answers++; try { p.write("yes\r"); } catch (_) {} }
        else if (autopass && /(?:[Pp]assword|[Pp]assphrase)(?:\s+for\s+\S+)?:\s*$/.test(tail)) { answers++; try { p.write(autopass + "\r"); } catch (_) {} }
      }
    });
    // Shape the captured output once; used by both normal exit and the timeout fallback.
    const done = (code) => { let c = clean(out).trim(); if (autopass) c = c.split(autopass).join("***"); c = redactor.redactString(c); finish({ ok: true, code, killed, output: c.length > cap ? c.slice(0, cap) + "\n...[truncated]" : (c || "(no output)") }); };
    p.onExit(({ exitCode }) => done(exitCode));
    to = setTimeout(() => {
      killed = true;
      try { p.kill(); } catch (_) {}                                     // polite first (node-pty default is SIGHUP)
      setTimeout(() => { try { p.kill("SIGKILL"); } catch (_) {} }, 2000); // escalate if the child ignores SIGHUP
      setTimeout(() => done(null), 3500);                                // guarantee the promise resolves even if onExit never fires
    }, timeout || 60000);
    return;
  }
  let p;
  try { p = isWin ? spawn("cmd.exe", ["/c", command], { cwd: workdir }) : spawn("/bin/sh", ["-c", command], { cwd: workdir }); }
  catch (err) { return finish({ ok: false, error: err.message }); }
  p.stdout.setEncoding("utf8"); p.stderr.setEncoding("utf8"); // decode across chunk boundaries before the model sees it
  const add = (d) => { if (out.length < cap + 200) out += d; };
  p.stdout.on("data", add); p.stderr.on("data", add);
  p.on("close", (code) => { let c = out; if (autopass) c = c.split(autopass).join("***"); c = redactor.redactString(c); finish({ ok: true, code, killed, output: c.length > cap ? c.slice(0, cap) + "\n...[truncated]" : (c || "(no output)") }); });
  p.on("error", (err) => finish({ ok: false, error: err.message }));
  to = setTimeout(() => { killed = true; try { p.kill("SIGKILL"); } catch (_) {} }, timeout || 60000);
}));

// ---- Auto-configure a tool: install on first use, streaming progress. ----
// Privileged installs go through pkexec (graphical prompt); no password stored.
ipcMain.handle("tool:install", (_e, { id, install }) => new Promise((res) => {
  let cmd = String(install || "").trim();
  if (cmd.startsWith("sudo ")) cmd = "pkexec " + cmd.slice(5).replace(/^apt install/, "apt-get install");
  const p = spawn("/bin/bash", ["-lc", cmd]);
  p.stdout.setEncoding("utf8"); p.stderr.setEncoding("utf8"); // decode across chunk boundaries (multibyte-safe)
  const send = (c) => toUi("tool:install:data", { id, chunk: c });
  p.stdout.on("data", send); p.stderr.on("data", send);
  p.on("close", (code) => res({ ok: code === 0, code, cmd }));
  p.on("error", (e) => { send("[error] " + e.message + "\n"); res({ ok: false, error: e.message, cmd }); });
}));

// ---- interactive PTYs (real terminals, one per tab) ----
ipcMain.handle("pty:spawn", (_e, { cols, rows }) => {
  if (!nodePty) return { ok: false, error: "node-pty is not available in this build" };
  const id = "p" + (++ptySeq);
  const shell = isWin ? "powershell.exe" : (process.env.SHELL || "/bin/bash");
  let p;
  try { p = nodePty.spawn(shell, [], { name: "xterm-color", cols: cols || 80, rows: rows || 24, cwd: os.homedir(), env: process.env }); }
  catch (e) { return { ok: false, error: e.message }; }
  ptys.set(id, p);
  p.onData((d) => toUi("pty:data", { id, data: d }));
  p.onExit(() => { ptys.delete(id); toUi("pty:exit", { id }); });
  return { ok: true, id, shell };
});
ipcMain.handle("pty:write", (_e, { id, data }) => { const p = ptys.get(id); if (p) { try { p.write(data); } catch (_) {} } }); // keystrokes can race pty exit
ipcMain.handle("pty:resize", (_e, { id, cols, rows }) => { const p = ptys.get(id); if (p) { try { p.resize(cols, rows); } catch (_) {} } });
ipcMain.handle("pty:kill", (_e, { id }) => { const p = ptys.get(id); if (p) { try { p.kill(); } catch (_) {} ptys.delete(id); } });

// Is a tool on PATH? Sanitize name to prevent shell injection.
ipcMain.handle("which", (_e, name) => new Promise((res) => {
  name = String(name || "").replace(/[^a-zA-Z0-9_.+-]/g, "");
  if (!name) return res({ found: false });
  const cmd = isWin ? "where " + name : "command -v " + name;
  const p = isWin ? spawn("cmd.exe", ["/c", cmd]) : spawn("/bin/sh", ["-c", cmd]);
  let out = "";
  p.stdout.on("data", (d) => (out += d));
  p.on("close", (c) => res({ found: c === 0, path: out.trim() }));
  p.on("error", () => res({ found: false }));
}));

// Proxy local Ollama (avoids renderer file:// CORS).
ipcMain.handle("ollama", (_e, { path: pth, body }) => new Promise((res) => {
  const data = body ? JSON.stringify(body) : null;
  const req = http.request(
    { host: "127.0.0.1", port: 11434, path: pth, method: data ? "POST" : "GET",
      headers: data ? { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } : {} },
    (r) => { let b = ""; r.on("data", (d) => (b += d)); r.on("end", () => { try { res({ ok: true, data: JSON.parse(b) }); } catch (_) { res({ ok: true, data: b }); } }); }
  );
  req.on("error", (err) => res({ ok: false, error: err.message }));
  if (data) req.write(data);
  req.end();
}));

// Streaming Ollama chat: emits ollama:token events live, resolves with the full
// assembled message (content + tool_calls) when the stream ends.
const streamReqs = new Map();
ipcMain.handle("ollama:stream", (_e, { id, body }) => new Promise((resolve) => {
  // keep_alive: keep the model resident for 30m so agentic multi-step turns don't
  // pay a cold ~8s reload each step (the main cause of the "glitchy/hung" feel).
  // Caller can still override by setting keep_alive on the body.
  const data = JSON.stringify(Object.assign({ keep_alive: "30m" }, body, { stream: true }));
  let content = "", toolCalls = null, settled = false;
  const done = (v) => { if (settled) return; settled = true; streamReqs.delete(id); resolve(v); };
  const req = http.request(
    { host: "127.0.0.1", port: 11434, path: "/api/chat", method: "POST",
      headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } },
    (r) => {
      r.setEncoding("utf8"); // decode on the stream so a multibyte char split across chunks is never mangled
      let buf = "";
      const pump = (d) => {
        buf += d; let nl;
        while ((nl = buf.indexOf("\n")) >= 0) {
          const line = buf.slice(0, nl).trim(); buf = buf.slice(nl + 1); if (!line) continue;
          let j; try { j = JSON.parse(line); } catch (_) { continue; }
          if (j.error) { done({ ok: false, error: j.error }); return; }
          const m = j.message || {};
          if (m.content) { content += m.content; toUi("ollama:token", { id, chunk: m.content }); }
          if (m.tool_calls && m.tool_calls.length) toolCalls = (toolCalls || []).concat(m.tool_calls);
        }
      };
      r.on("data", pump);
      r.on("end", () => { if (buf.trim()) pump("\n"); done({ ok: true, message: { role: "assistant", content, tool_calls: toolCalls || undefined } }); });
      r.on("error", (err) => done({ ok: false, error: err.message }));
    }
  );
  req.on("error", (err) => done({ ok: false, error: err.message }));
  streamReqs.set(id, req);
  req.write(data); req.end();
}));
ipcMain.handle("ollama:cancel", (_e, id) => { const rq = streamReqs.get(id); if (rq) { try { rq.destroy(); } catch (_) {} streamReqs.delete(id); } return true; });

// ---- Claude (Anthropic) streaming — the cloud engine for the Assistant ----
// Mirrors ollama:stream's contract: streams claude:token events and resolves with
// { ok, message:{content}, usage:{inTok,outTok} }. Key comes from the request
// (Assistant settings) or the ANTHROPIC_API_KEY env var. For authorized security work.
const claudeReqs = new Map();
ipcMain.handle("claude:stream", (_e, { id, body, apiKey }) => new Promise((resolve) => {
  const key = apiKey || process.env.ANTHROPIC_API_KEY || "";
  if (!key) { resolve({ ok: false, error: "no Anthropic API key — add one in the Assistant settings (gear) or set ANTHROPIC_API_KEY" }); return; }
  const data = JSON.stringify(Object.assign({}, toAnthropicBody(body), { stream: true }));
  let content = "", inTok = 0, outTok = 0, settled = false;
  const done = (v) => { if (settled) return; settled = true; claudeReqs.delete(id); resolve(v); };
  const req = https.request(
    { host: "api.anthropic.com", path: "/v1/messages", method: "POST",
      headers: { "content-type": "application/json", "content-length": Buffer.byteLength(data), "x-api-key": key, "anthropic-version": "2023-06-01" } },
    (r) => {
      if (r.statusCode >= 400) { let e = ""; r.on("data", (d) => (e += d)); r.on("end", () => { let msg = e; try { const j = JSON.parse(e); msg = (j.error && j.error.message) || e; } catch (_) {} done({ ok: false, error: "Anthropic " + r.statusCode + ": " + msg }); }); return; }
      r.setEncoding("utf8"); // decode on the stream so a multibyte char split across chunks is never mangled
      let buf = "";
      const pump = (d) => {
        buf += d; let nl;
        while ((nl = buf.indexOf("\n")) >= 0) {
          const line = buf.slice(0, nl).trim(); buf = buf.slice(nl + 1);
          if (!line.startsWith("data:")) continue;
          const p = line.slice(5).trim(); if (!p || p === "[DONE]") continue;
          let o; try { o = JSON.parse(p); } catch (_) { continue; }
          if (o.type === "error") { done({ ok: false, error: (o.error && o.error.message) || "stream error" }); return; }
          const txt = anthropicDelta(o); if (txt) { content += txt; toUi("claude:token", { id, chunk: txt }); }
          const u = usageOf(o); if (u) { if (u.inTok) inTok = u.inTok; if (u.outTok) outTok = u.outTok; }
        }
      };
      r.on("data", pump);
      r.on("end", () => { if (buf.trim()) pump("\n"); done({ ok: true, message: { role: "assistant", content }, usage: { inTok, outTok } }); });
      r.on("error", (err) => done({ ok: false, error: err.message }));
    }
  );
  req.on("error", (err) => done({ ok: false, error: err.message }));
  claudeReqs.set(id, req);
  req.write(data); req.end();
}));
ipcMain.handle("claude:cancel", (_e, id) => { const rq = claudeReqs.get(id); if (rq) { try { rq.destroy(); } catch (_) {} claudeReqs.delete(id); } return true; });

// ---- Any model (OpenAI-compatible) streaming — OpenRouter, Groq, DeepSeek, Together,
// Mistral, LM Studio, vLLM, llama.cpp, … Mirrors ollama:stream's contract: emits
// api:token events, resolves with { ok, message:{content,tool_calls}, usage }. base +
// apiKey + model come from the Assistant settings. Tool-call args are parsed to objects
// so the planner sees the SAME shape Ollama returns.
const apiReqs = new Map();
function mergeToolCallDeltas(acc, deltas) {
  acc = acc || [];
  for (const d of deltas) {
    const i = typeof d.index === "number" ? d.index : acc.length;
    acc[i] = acc[i] || { id: "", type: "function", function: { name: "", arguments: "" } };
    if (d.id) acc[i].id = d.id;
    if (d.type) acc[i].type = d.type;
    if (d.function) { if (d.function.name) acc[i].function.name = d.function.name; if (d.function.arguments) acc[i].function.arguments += d.function.arguments; }
  }
  return acc;
}
ipcMain.handle("api:stream", (_e, { id, body, base, apiKey, model }) => new Promise((resolve) => {
  let url;
  try { url = new URL(String(base || "").replace(/\/+$/, "") + "/chat/completions"); }
  catch (e) { resolve({ ok: false, error: "invalid API base URL: " + base }); return; }
  const lib = url.protocol === "https:" ? https : http;
  const payload = Object.assign({}, body, { stream: true }); if (model) payload.model = model;
  // translate Ollama-shaped fields to OpenAI schema: temperature lives at top level,
  // and format(JSON schema) → response_format so structured output is actually enforced.
  if (payload.options && typeof payload.options.temperature === "number") payload.temperature = payload.options.temperature;
  if (payload.format) payload.response_format = { type: "json_object" };
  delete payload.options; delete payload.format; delete payload.keep_alive; delete payload.num_ctx;
  const data = JSON.stringify(payload);
  const headers = { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) };
  const key = apiKey || process.env.DARKNODE_API_KEY || process.env.OPENAI_API_KEY || "";
  if (key) headers["Authorization"] = "Bearer " + key;
  let content = "", toolCalls = null, inTok = 0, outTok = 0, settled = false;
  const done = (v) => { if (settled) return; settled = true; apiReqs.delete(id); resolve(v); };
  const req = lib.request(
    { hostname: url.hostname, port: url.port || (url.protocol === "https:" ? 443 : 80), path: url.pathname + url.search, method: "POST", headers },
    (r) => {
      if (r.statusCode >= 400) { let e = ""; r.on("data", (d) => (e += d)); r.on("end", () => { let msg = e; try { const j = JSON.parse(e); msg = (j.error && j.error.message) || e; } catch (_) {} done({ ok: false, error: "API " + r.statusCode + ": " + String(msg).slice(0, 300) }); }); return; }
      r.setEncoding("utf8"); // decode on the stream so a multibyte char split across chunks is never mangled
      let buf = "";
      const pump = (d) => {
        buf += d; let nl;
        while ((nl = buf.indexOf("\n")) >= 0) {
          const line = buf.slice(0, nl).trim(); buf = buf.slice(nl + 1);
          if (!line.startsWith("data:")) continue;
          const p = line.slice(5).trim(); if (!p || p === "[DONE]") continue;
          let o; try { o = JSON.parse(p); } catch (_) { continue; }
          if (o.error) { done({ ok: false, error: (o.error && o.error.message) || "stream error" }); return; }
          const ch = (o.choices && o.choices[0]) || {}, delta = ch.delta || {};
          if (delta.content) { content += delta.content; toUi("api:token", { id, chunk: delta.content }); }
          if (delta.tool_calls && delta.tool_calls.length) toolCalls = mergeToolCallDeltas(toolCalls, delta.tool_calls);
          if (o.usage) { inTok = o.usage.prompt_tokens || inTok; outTok = o.usage.completion_tokens || outTok; }
        }
      };
      r.on("data", pump);
      r.on("end", () => {
        if (buf.trim()) pump("\n");
        const tc = toolCalls ? toolCalls.filter(Boolean).map((t) => ({ id: t.id, type: t.type, function: { name: t.function.name, arguments: (() => { try { return JSON.parse(t.function.arguments || "{}"); } catch (_) { return t.function.arguments; } })() } })) : null;
        done({ ok: true, message: { role: "assistant", content, tool_calls: tc && tc.length ? tc : undefined }, usage: { inTok, outTok } });
      });
      r.on("error", (err) => done({ ok: false, error: err.message }));
    }
  );
  req.on("error", (err) => done({ ok: false, error: err.message }));
  apiReqs.set(id, req);
  req.write(data); req.end();
}));
ipcMain.handle("api:cancel", (_e, id) => { const rq = apiReqs.get(id); if (rq) { try { rq.destroy(); } catch (_) {} apiReqs.delete(id); } return true; });

// Darknode AI (cloud): routes the app's default assistant through the darknode.ai
// proxy (Cloudflare worker) so no API key lives on the device. Sends cite:false
// so answers never carry a Sources list. Streams dai:token and resolves with the
// assembled message — same contract as ollama:stream / api:stream.
const daiReqs = new Map();
ipcMain.handle("dai:stream", (_e, { id, messages }) => new Promise((resolve) => {
  const data = JSON.stringify({ provider: "darknode", model: "darknode", cite: false, messages: messages || [] });
  let content = "", settled = false;
  const done = (v) => { if (settled) return; settled = true; daiReqs.delete(id); resolve(v); };
  const req = https.request(
    { hostname: "darknode-proxy.darknode-ai.workers.dev", port: 443, path: "/api/chat", method: "POST",
      headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } },
    (r) => {
      if (r.statusCode >= 400) { let e = ""; r.on("data", (d) => (e += d)); r.on("end", () => { let msg = e; try { const j = JSON.parse(e); msg = (j && j.error) || e; } catch (_) {} done({ ok: false, error: "Darknode AI " + r.statusCode + ": " + String(msg).slice(0, 300) }); }); return; }
      r.setEncoding("utf8"); // decode on the stream so a multibyte char split across chunks is never mangled
      let buf = "";
      const pump = (d) => {
        buf += d; let nl;
        while ((nl = buf.indexOf("\n")) >= 0) {
          const line = buf.slice(0, nl).trim(); buf = buf.slice(nl + 1);
          if (!line.startsWith("data:")) continue;
          const p = line.slice(5).trim(); if (!p || p === "[DONE]") continue;
          let o; try { o = JSON.parse(p); } catch (_) { continue; }
          const ch = (o.choices && o.choices[0]) || {}, delta = ch.delta || {};
          if (delta.content) { content += delta.content; toUi("dai:token", { id, chunk: delta.content }); }
        }
      };
      r.on("data", pump);
      r.on("end", () => { if (buf.trim()) pump("\n"); done({ ok: true, message: { role: "assistant", content } }); });
      r.on("error", (err) => done({ ok: false, error: err.message }));
    }
  );
  req.on("error", (err) => done({ ok: false, error: err.message }));
  daiReqs.set(id, req);
  req.write(data); req.end();
}));
ipcMain.handle("dai:cancel", (_e, id) => { const rq = daiReqs.get(id); if (rq) { try { rq.destroy(); } catch (_) {} daiReqs.delete(id); } return true; });

// ---- enterprise governance: usage ledger + signed compliance bundle ----
const govCwd = () => { try { return app.getPath("userData"); } catch (_) { return os.homedir(); } };
// Scope-authorization enforcer (DA-009). Lazily built so app paths are ready.
// Active capabilities (scan/fuzz/subdomains/tls/http) are gated by scope().enforce().
let _scope = null;
const scope = () => _scope || (_scope = new ScopeEnforcer(govCwd()));

// DA-008: OS-keychain-backed credential vault. Values are encrypted with the
// current OS user's safeStorage key (macOS Keychain / Windows DPAPI / Linux
// libsecret-kwallet) and written as ciphertext to <userData>/.nexus/secrets.enc
// (mode 0600). Every value read/written is registered with the redactor so it
// is scrubbed from logs, transcripts, and the usage ledger.
let _vault = null;
const vault = () => _vault || (_vault = createVault({ cwd: govCwd(), backend: electronBackend(safeStorage, process.platform) }));
ipcMain.handle("secret:set", (_e, { name, value }) => { try { const r = vault().set(name, value); if (r.ok) redactor.registerSecret(value); return r; } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });
ipcMain.handle("secret:get", (_e, name) => { try { const v = vault().get(name); if (v != null) redactor.registerSecret(v); return { ok: true, value: v }; } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });
ipcMain.handle("secret:has", (_e, name) => { try { return { ok: true, has: vault().has(name) }; } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });
ipcMain.handle("secret:list", () => { try { return { ok: true, secrets: vault().list() }; } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });
ipcMain.handle("secret:remove", (_e, name) => { try { return vault().remove(name); } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });
ipcMain.handle("secret:mode", () => { try { return vault().mode(); } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });
ipcMain.handle("scope:authorize", (_e, rec) => { try { return scope().addAuthorization(rec || {}); } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });
ipcMain.handle("scope:list", () => { try { return { ok: true, records: scope().list() }; } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });
ipcMain.handle("scope:revoke", (_e, id) => { try { return scope().revoke(id); } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });
ipcMain.handle("scope:check", (_e, { kind, target }) => { try { return scope().preview(kind, target); } catch (e) { return { allowed: false, reason: String((e && e.message) || e) }; } });
ipcMain.handle("gov:identity", () => { try { return resolveOperator({ cwd: govCwd() }); } catch (_) { return { operator: "unknown", team: "", source: "os" }; } });
ipcMain.handle("gov:usage:append", (_e, rec) => { try { return appendUsage(govCwd(), redactor.redact(rec || {})); } catch (_) { return false; } });
ipcMain.handle("gov:usage:report", (_e, opts) => { try { const recs = loadUsage(govCwd(), (opts && opts.since) ? { since: opts.since } : {}); const s = summarize(recs); return { ok: true, summary: s, text: renderReport(s, { project: "Darknode Assistant" }), count: recs.length }; } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });
ipcMain.handle("gov:compliance:build", (_e, opts) => {
  try {
    opts = opts || {}; const cwd = govCwd(); const id = resolveOperator({ cwd });
    const key = opts.signingKey || process.env.DARKNODE_SIGNING_KEY || "";
    const b = buildBundle(cwd, { operator: opts.operator || id.operator, team: opts.team || id.team, signingKey: key || undefined });
    let outPath = null;
    try { const dir = path.join(cwd, ".nexus"); fs.mkdirSync(dir, { recursive: true }); const stamp = new Date().toISOString().replace(/[:.]/g, "-"); outPath = path.join(dir, "compliance-" + stamp + ".json"); fs.writeFileSync(outPath, JSON.stringify(b, null, 2)); fs.writeFileSync(outPath.replace(/\.json$/, ".md"), renderBundleMd(b)); } catch (_) {}
    return { ok: true, bundle: b, md: renderBundleMd(b), path: outPath };
  } catch (e) { return { ok: false, error: String((e && e.message) || e) }; }
});
ipcMain.handle("gov:compliance:verify", (_e, { bundle, signingKey }) => { try { return Object.assign({ ok: true }, verifyBundle(bundle, signingKey || process.env.DARKNODE_SIGNING_KEY || undefined)); } catch (e) { return { ok: false, error: String((e && e.message) || e) }; } });

// ---- Workstation Security Audit (CIS Level 1-style, read-only) ----
// Runs fixed status/query commands for the local machine and parses their real
// output. execFile (never a shell), a per-command timeout, and NO privilege
// escalation: a command that is missing, not applicable, or needs root reports
// `na`/`error` honestly rather than guessing. Evidence is scrubbed through the
// redactor before it leaves the main process.
const AUDIT_ALLOWED = new Set([
  "fdesetup", "/usr/libexec/ApplicationFirewall/socketfilterfw", "defaults", "sysadminctl",
  "spctl", "csrutil", "sshd", "systemsetup", "lsof", "ls", "manage-bde", "netsh", "sc",
  "reg", "powershell", "net", "schtasks", "w32tm", "lsblk", "dmsetup", "ufw", "firewall-cmd",
  "nft", "iptables", "apt-config", "systemctl", "gsettings", "ps", "cat", "getent", "ss",
  "timedatectl", "mokutil",
]);
function auditExec(bin, args) {
  return new Promise((resolve) => {
    if (!AUDIT_ALLOWED.has(bin)) { resolve({ na: true, reason: "command not permitted by audit allowlist" }); return; }
    let done = false;
    const finish = (v) => { if (!done) { done = true; resolve(v); } };
    try {
      const child = execFile(bin, args || [], { timeout: 8000, maxBuffer: 4 * 1024 * 1024, windowsHide: true },
        (err, stdout, stderr) => {
          if (err && err.code === "ENOENT") { finish({ na: true, reason: "command not found (" + bin + ")" }); return; }
          if (err && err.killed) { finish({ error: "timed out after 8s", code: -1, stdout: String(stdout || ""), stderr: String(stderr || "") }); return; }
          finish({ ok: true, code: (err && typeof err.code === "number") ? err.code : 0, stdout: String(stdout || ""), stderr: String(stderr || "") });
        });
      child.on("error", (e) => { if (e && e.code === "ENOENT") finish({ na: true, reason: "command not found (" + bin + ")" }); else finish({ error: String((e && e.message) || e), code: -1, stdout: "", stderr: "" }); });
    } catch (e) { finish({ error: String((e && e.message) || e), code: -1, stdout: "", stderr: "" }); }
  });
}
function osDescription() {
  try {
    const p = process.platform;
    if (p === "darwin") return "macOS " + os.release();
    if (p === "win32") return "Windows " + os.release();
    return (os.type() || "Linux") + " " + os.release();
  } catch (_) { return process.platform; }
}
ipcMain.handle("audit:run", async () => {
  try {
    const report = await hardeningAudit.runAudit({
      platform: process.platform,
      exec: auditExec,
      host: os.hostname(),
      osDescription: osDescription(),
      appVersion: app.getVersion(),
    });
    // Scrub any secret-shaped content out of every evidence string before it
    // reaches the renderer / any export.
    for (const r of report.results) { try { r.evidence = redactor.redact(r.evidence); } catch (_) {} }
    return { ok: true, report };
  } catch (e) { return { ok: false, error: String((e && e.message) || e) }; }
});
ipcMain.handle("audit:export", (_e, { report, format }) => {
  try {
    if (!report || !Array.isArray(report.results)) return { ok: false, error: "no report" };
    let text, ext, mime;
    if (format === "csv") { text = hardeningAudit.toCSV(report); ext = "csv"; mime = "text/csv"; }
    else if (format === "txt") { text = hardeningAudit.toText(report); ext = "txt"; mime = "text/plain"; }
    else if (format === "fleet") { text = JSON.stringify(hardeningAudit.toFleetRecord(report), null, 2); ext = "json"; mime = "application/json"; }
    else { text = hardeningAudit.toJSON(report); ext = "json"; mime = "application/json"; }
    return { ok: true, text, ext, mime };
  } catch (e) { return { ok: false, error: String((e && e.message) || e) }; }
});

ipcMain.handle("audit:save", async (_e, { text, defaultName, ext }) => {
  try {
    const r = await dialog.showSaveDialog(win, { defaultPath: defaultName || ("workstation-audit." + (ext || "txt")) });
    if (r.canceled || !r.filePath) return { ok: false, canceled: true };
    await fs.promises.writeFile(r.filePath, String(text == null ? "" : text), "utf8");
    return { ok: true, path: r.filePath };
  } catch (e) { return { ok: false, error: String((e && e.message) || e) }; }
});

ipcMain.handle("openExternal", (_e, url) => {
  // Only open web URLs in the OS browser -- never file://, or app/protocol-handler
  // schemes a browsed/redirected page could smuggle in.
  try { const p = new URL(String(url)).protocol; if (p === "http:" || p === "https:") return shell.openExternal(url); } catch (_) {}
  return false;
});

// ---- Web shell: Google sign-in via the system browser (D0) ----
// Google blocks OAuth inside embedded browsers, so the page asks the app. The
// system browser runs loopback + PKCE and only the Google ID token comes back;
// the page signs in to Firebase with it. One flow at a time; a new request
// cancels the previous one. Nothing here logs or stores the token.
const GOOGLE_SIGNIN = {
  clientId: process.env.DARKNODE_GOOGLE_CLIENT_ID || _oauthCfg.googleSignInClientId || _oauthCfg.gmailClientId || "",
  clientSecret: process.env.DARKNODE_GOOGLE_CLIENT_SECRET || _oauthCfg.googleSignInClientSecret || (_oauthCfg.googleSignInClientId ? "" : _oauthCfg.gmailClientSecret) || "",
};
let _cancelGoogle = null;
ipcMain.handle("auth:google", async () => {
  if (_cancelGoogle) { try { _cancelGoogle(); } catch (_) {} }
  const r = await runGoogleSignIn({
    http, fetchImpl: fetch, openExternal: (u) => shell.openExternal(u),
    clientId: GOOGLE_SIGNIN.clientId, clientSecret: GOOGLE_SIGNIN.clientSecret,
    onCancel: (fn) => { _cancelGoogle = fn; },
  });
  _cancelGoogle = null;
  if (r.ok && win) { if (win.isMinimized()) win.restore(); win.focus(); }
  return r.ok ? { ok: true, idToken: r.idToken } : { ok: false, error: r.error };
});

// Recolour the native window-controls overlay so it matches the page's top bar.
ipcMain.handle("shell:titlebar", (_e, opts) => {
  if (!win || process.platform === "darwin" || typeof win.setTitleBarOverlay !== "function") return false;
  const hex = (v) => (typeof v === "string" && /^#[0-9a-f]{6}$/i.test(v) ? v : undefined);
  const o = {};
  if (hex(opts && opts.color)) o.color = opts.color;
  if (hex(opts && opts.symbolColor)) o.symbolColor = opts.symbolColor;
  const h = Number(opts && opts.height);
  if (Number.isInteger(h) && h >= 28 && h <= 80) o.height = h;
  if (!Object.keys(o).length) return false;
  try { win.setTitleBarOverlay(o); return true; } catch (_) { return false; }
});

// ---- custom (frameless) window controls ----
// Each acts on the window that asked (the main window, or the native tools window).
const callerWin = (e) => { try { return BrowserWindow.fromWebContents(e.sender); } catch (_) { return null; } };
ipcMain.handle("win:minimize", (e) => { const w = callerWin(e); if (w) w.minimize(); });
ipcMain.handle("win:maximize", (e) => { const w = callerWin(e); if (!w) return false; w.isMaximized() ? w.unmaximize() : w.maximize(); return w.isMaximized(); });
ipcMain.handle("win:close", (e) => { const w = callerWin(e); if (w) w.close(); });
ipcMain.handle("win:close-now", (e) => { // user confirmed closing with work in flight
  const w = callerWin(e);
  if (w && w === nativeWin && typeof w._dnForceClose === "function") { w._dnForceClose(); return; }
  _forceClose = true; if (win) win.close();
});

// ---- Web shell: installed local models (Ollama tags, read-only; no prompt is sent) ----
ipcMain.handle("local:models", () => new Promise((res) => {
  const req = http.get({ host: "127.0.0.1", port: 11434, path: "/api/tags", timeout: 2500 }, (r) => {
    let b = ""; r.on("data", (d) => { if (b.length < 2e6) b += d; });
    r.on("end", () => { try { const j = JSON.parse(b); res({ ok: true, models: (j.models || []).slice(0, 200).map((m) => ({ name: String(m.name || ""), size: Number(m.size) || 0, family: String((m.details && m.details.family) || ""), params: String((m.details && m.details.parameter_size) || "") })) }); } catch (_) { res({ ok: false, error: "unexpected reply from Ollama" }); } });
  });
  req.on("timeout", () => { req.destroy(); res({ ok: false, error: "Ollama is not running on this computer" }); });
  req.on("error", () => res({ ok: false, error: "Ollama is not running on this computer" }));
}));

// ---- Web shell: open the native tools window (optionally on one section) ----
// extra.type: one line of text typed into a new Terminal tab. It is never sent with Enter;
// the user reads it and runs it (or not) in the terminal.
const typeable = (t) => (typeof t === "string" && t.length > 0 && t.length <= 1000 && !/[\x00-\x1f\x7f]/.test(t) ? t : "");
ipcMain.handle("native:open", (_e, sec, extra) => {
  if (SHELL !== "web") return false;
  const s = typeof sec === "string" && NATIVE_SECTIONS.has(sec) ? sec : "";
  const type = s === "runner" ? typeable(extra && extra.type) : "";
  openNativeWindow(s, type);
  return true;
});

// ---- CVE search (NVD) + CISA KEV enrichment ----
// The KEV catalog is fetched once per process and cached; it flags which of the
// returned CVEs are KNOWN to be actively exploited in the wild.
let _mainKevIndex = null, _mainKevFetchedAt = 0;
async function kevIndex() {
  if (_mainKevIndex && (Date.now() - _mainKevFetchedAt) < 6 * 3600e3) return _mainKevIndex;
  try {
    const r = await fetch("https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json", { headers: { "User-Agent": "Darknode" } });
    if (r.ok) { const d = await r.json(); _mainKevIndex = cveLib.buildKevIndex(d && d.vulnerabilities); _mainKevFetchedAt = Date.now(); }
  } catch (_) {}
  return _mainKevIndex;
}
ipcMain.handle("cve:search", async (_e, q, opts) => {
  q = (q || "").trim(); if (!q) return { ok: false, error: "empty query" };
  const isId = /^CVE-\d{4}-\d+$/i.test(q);
  const perPage = Math.min(Math.max((opts && +opts.perPage) || 20, 1), 100);
  const startIndex = Math.max((opts && +opts.startIndex) || 0, 0);
  const url = "https://services.nvd.nist.gov/rest/json/cves/2.0?" + (isId ? "cveId=" + q.toUpperCase() : "keywordSearch=" + encodeURIComponent(q)) + "&resultsPerPage=" + perPage + "&startIndex=" + startIndex;
  try {
    const r = await fetch(url, { headers: { "User-Agent": "Darknode" } });
    if (!r.ok) return { ok: false, error: r.status === 403 ? "NVD rate limit — wait a moment" : r.status + " " + r.statusText };
    const d = await r.json();
    const norm = cveLib.normalizeNvd(d);
    try { const idx = await kevIndex(); if (idx) cveLib.markKev(norm.list, idx); } catch (_) {}
    return { ok: true, total: norm.total, startIndex, perPage, count: norm.list.length, list: norm.list };
  } catch (e) { return { ok: false, error: e.message }; }
});

// Read a response body as text but stop after ~maxChars, so a large download can't
// balloon main-process memory (the abort timer bounds time, not volume) and a body
// above V8's string limit can't throw a RangeError inside res.text().
async function readTextCapped(res, maxChars) {
  const body = res.body;
  if (!body || typeof body.getReader !== "function") {
    const t = await res.text();
    return t.length > maxChars ? t.slice(0, maxChars) + "\n...[truncated]" : t;
  }
  const reader = body.getReader(), dec = new TextDecoder();
  let out = "";
  try {
    while (out.length < maxChars) {
      const { done, value } = await reader.read();
      if (done) break;
      out += dec.decode(value, { stream: true });
    }
    out += dec.decode();
  } finally { try { await reader.cancel(); } catch (_) {} }
  return out.length > maxChars ? out.slice(0, maxChars) + "\n...[truncated]" : out;
}

// ---- HTTP request tool (repeater). Runs in main to dodge renderer CSP/CORS. ----
ipcMain.handle("http:request", async (_e, { method, url, headers, body, timeout }) => {
  const t0 = Date.now();
  { const g = scope().enforce("http", url); if (!g.allowed) return { ok: false, blocked: true, error: g.reason, ms: 0 }; }
  const ctrl = new AbortController();
  const to = setTimeout(() => ctrl.abort(), timeout || 20000);
  try {
    const m = (method || "GET").toUpperCase();
    // safeFetch enforces the SSRF guard on the initial host AND every redirect hop.
    const res = await safeFetch(url, {
      method: m, headers: headers || {},
      body: (m === "GET" || m === "HEAD") ? undefined : (body || undefined),
      signal: ctrl.signal,
    });
    const text = await readTextCapped(res, 200000);
    const hdrs = {}; res.headers.forEach((v, k) => (hdrs[k] = v));
    return { ok: true, status: res.status, statusText: res.statusText, url: res.url, headers: hdrs, body: text, ms: Date.now() - t0 };
  } catch (e) { return { ok: false, error: e.name === "AbortError" ? "request timed out" : e.message, ms: Date.now() - t0 }; }
  finally { clearTimeout(to); }
});

// ---- Loot: browse saved command output under ~/darknode-results ----
ipcMain.handle("results:list", async () => {
  try {
    const names = await fs.promises.readdir(RESULTS_DIR);
    const items = [];
    for (const n of names) {
      try { const st = await fs.promises.stat(path.join(RESULTS_DIR, n)); if (st.isFile()) items.push({ name: n, size: st.size, mtime: st.mtimeMs }); } catch (_) {}
    }
    items.sort((a, b) => b.mtime - a.mtime);
    return { ok: true, dir: RESULTS_DIR, items };
  } catch (e) {
    // The results folder is created lazily on the first saved run; until then a
    // missing directory is the normal empty state, not an error to show the user.
    if (e && e.code === "ENOENT") return { ok: true, dir: RESULTS_DIR, items: [] };
    return { ok: false, error: e.message, dir: RESULTS_DIR, items: [] };
  }
});
ipcMain.handle("results:read", async (_e, name) => {
  try {
    if (!name || name.includes("/") || name.includes("\\") || name.includes("..")) return { ok: false, error: "invalid file name" };
    const data = await fs.promises.readFile(path.join(RESULTS_DIR, name), "utf8");
    return { ok: true, name, data: data.length > 500000 ? data.slice(-500000) : data };
  } catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("results:reveal", () => shell.openPath(RESULTS_DIR));

// ---- Built-in TCP port scanner (native, no external tools). Streams hits live. ----
const scans = new Map();
ipcMain.handle("scan:cancel", (_e, id) => { const s = scans.get(id); if (s) s.cancelled = true; return true; });
ipcMain.handle("scan:ports", async (_e, { id, host, ports, timeout, concurrency }) => {
  const g = scope().enforce("scan", host);
  if (!g.allowed) { toUi("scan:done", { id, open: 0, cancelled: true, error: g.reason }); return { ok: false, blocked: true, error: g.reason }; }
  const state = { cancelled: false };
  scans.set(id, state);
  const r = await scanPorts(host, ports, {
    timeout, concurrency, signal: state,
    onHit: (port, banner) => { toUi("scan:hit", { id, port, banner }); },
    onProgress: (done, total) => { toUi("scan:progress", { id, done, total }); },
  });
  scans.delete(id);
  toUi("scan:done", { id, open: r.open, cancelled: r.cancelled });
  return { ok: true };
});

// ---- directory / content fuzzer (native, streams hits) ----
// Core logic lives in lib/recon/fuzz.js (headReq, fuzzDirs); this handler is the
// Electron binding that forwards hits/progress to the renderer.
const fuzzes = new Map();
ipcMain.handle("fuzz:cancel", (_e, id) => { const s = fuzzes.get(id); if (s) s.cancelled = true; return true; });
ipcMain.handle("fuzz:dirs", async (_e, { id, base, words, concurrency, timeout }) => {
  const g = scope().enforce("fuzz", base);
  if (!g.allowed) { toUi("fuzz:done", { id, hits: 0, cancelled: true, error: g.reason }); return { ok: false, blocked: true, error: g.reason }; }
  const state = { cancelled: false }; fuzzes.set(id, state);
  const r = await fuzzDirs(base, words, {
    timeout, concurrency, signal: state,
    onHit: (hit) => { toUi("fuzz:hit", { id, path: hit.path, status: hit.status, len: hit.len, loc: hit.loc }); },
    onProgress: (done, total) => { toUi("fuzz:progress", { id, done, total }); },
  });
  fuzzes.delete(id); toUi("fuzz:done", { id, hits: r.hits, cancelled: r.cancelled });
  return { ok: true };
});

// ---- DNS lookups (native resolver) ----
// Common DKIM selector names published by mainstream mail providers; we probe
// each at <selector>._domainkey.<domain> so the recon UI can show whether DKIM
// is actually deployed (there is no way to enumerate selectors from DNS alone).
const DKIM_SELECTORS = ["default", "google", "selector1", "selector2", "k1", "k2", "dkim", "mail", "s1", "s2", "mandrill", "mailjet", "smtp", "zoho", "fm1", "fm2", "fm3", "protonmail", "pm", "mx", "key1"];
// DNSSEC probe via DNS-over-HTTPS (Cloudflare). A real query with the DO bit
// set: the AD (Authenticated Data) flag and/or a DNSKEY answer (type 48) prove
// the zone is signed. We use a trusted, fixed public resolver (not safeFetch —
// same pattern as the NVD/crt.sh calls).
async function dohDnssec(host) {
  try {
    const r = await fetch("https://cloudflare-dns.com/dns-query?name=" + encodeURIComponent(host) + "&type=DNSKEY&do=1", { headers: { Accept: "application/dns-json", "User-Agent": "Darknode" } });
    if (!r.ok) return { ok: false, enabled: null, error: "resolver " + r.status };
    const d = await r.json();
    const dnskey = Array.isArray(d.Answer) && d.Answer.some((a) => a.type === 48);
    return { ok: true, enabled: !!d.AD || dnskey, ad: !!d.AD, dnskey };
  } catch (e) { return { ok: false, enabled: null, error: e.message }; }
}
ipcMain.handle("dns:lookup", async (_e, host) => {
  host = (host || "").trim().replace(/^https?:\/\//, "").split("/")[0];
  if (!host) return { ok: false, error: "no host" };
  const rec = {};
  const kinds = [["A", "resolve4"], ["AAAA", "resolve6"], ["MX", "resolveMx"], ["NS", "resolveNs"], ["TXT", "resolveTxt"], ["CNAME", "resolveCname"], ["SOA", "resolveSoa"], ["CAA", "resolveCaa"]];
  for (const [label, fn] of kinds) { try { rec[label] = await dns[fn](host); } catch (_) { rec[label] = null; } }
  try { if (rec.A && rec.A.length) rec.PTR = await dns.reverse(rec.A[0]).catch(() => null); } catch (_) {}
  // Email-auth + DNSSEC posture (skip for bare IP literals — these are domain concepts).
  const isIp = /^\d{1,3}(\.\d{1,3}){3}$/.test(host) || host.includes(":");
  if (!isIp) {
    try { rec.DMARC_TXT = await dns.resolveTxt("_dmarc." + host); } catch (_) { rec.DMARC_TXT = null; }
    const dkim = await Promise.all(DKIM_SELECTORS.map(async (sel) => {
      try { const records = await dns.resolveTxt(sel + "._domainkey." + host); return { selector: sel, records }; }
      catch (_) { return null; }
    }));
    rec.DKIM_RAW = dkim.filter(Boolean);
    rec.DNSSEC = await dohDnssec(host);
  }
  return { ok: true, host, rec };
});

// ---- WHOIS (native, follows the IANA referral) ----
function whoisAsk(server, query) {
  return new Promise((res) => {
    const s = net.connect(43, server); let data = "";
    s.setTimeout(9000);
    s.on("connect", () => s.write(query + "\r\n"));
    s.on("data", (d) => (data += d.toString("utf8")));
    s.on("end", () => res(data));
    s.on("timeout", () => { try { s.destroy(); } catch (_) {} res(data); });
    s.on("error", () => res(data));
  });
}
ipcMain.handle("whois:query", async (_e, query) => {
  query = String(query || "").trim().replace(/^https?:\/\//, "").split("/")[0];
  if (!query) return { ok: false, error: "no query" };
  if (!/^[\p{L}\p{N}._:-]{1,253}$/u.test(query)) return { ok: false, error: "enter a domain name or IP address" }; // CR/LF would send extra lines to the whois server
  try {
    let txt = await whoisAsk("whois.iana.org", query);
    const refer = (txt.match(/refer:\s*(\S+)/i) || [])[1] || (txt.match(/whois:\s*(\S+)/i) || [])[1];
    if (refer) { const more = await whoisAsk(refer, query); if (more && more.trim()) txt = more; }
    return { ok: true, query, text: txt.trim() || "no data" };
  } catch (e) { return { ok: false, error: e.message }; }
});

// ---- TLS / certificate inspector ----
ipcMain.handle("tls:cert", async (_e, { host, port }) => {
  host = (host || "").trim().replace(/^https?:\/\//, "").split("/")[0];
  port = port || 443;
  { const g = scope().enforce("tls", host); if (!g.allowed) return { ok: false, blocked: true, error: g.reason }; }
  return new Promise((res) => {
    let done = false; const finish = (v) => { if (done) return; done = true; res(v); };
    const s = tls.connect({ host, port, servername: host, rejectUnauthorized: false, timeout: 9000 }, () => {
      const c = s.getPeerCertificate(false);
      const flat = (o) => Object.entries(o || {}).map(([k, v]) => k + "=" + v).join(", ");
      finish({ ok: true, cert: {
        subject: flat(c.subject), issuer: flat(c.issuer), valid_from: c.valid_from, valid_to: c.valid_to,
        san: (c.subjectaltname || "").replace(/DNS:/g, ""), fingerprint256: c.fingerprint256, serial: c.serialNumber,
        bits: c.bits || "", protocol: s.getProtocol(), cipher: (s.getCipher() || {}).name,
        daysLeft: c.valid_to ? Math.round((new Date(c.valid_to) - Date.now()) / 86400000) : null,
      } });
      s.end();
    });
    s.on("error", (e) => finish({ ok: false, error: e.message }));
    s.on("timeout", () => { try { s.destroy(); } catch (_) {} finish({ ok: false, error: "connection timed out" }); });
  });
});

// ---- GitHub integration: clone / status / commit & push ----
const REPOS_DIR = path.join(os.homedir(), "darknode-repos");
function git(args, opts) {
  return new Promise((resolve, reject) => {
    execFile("git", args, { maxBuffer: 1e7, ...opts }, (err, stdout, stderr) => {
      if (err) { err.stdout = stdout; err.stderr = stderr; reject(err); } else resolve({ stdout, stderr });
    });
  });
}
const authUrl = (url, token) => (token && /^https:\/\//i.test(url)) ? url.replace(/^https:\/\//i, "https://" + token + "@") : url;
const scrub = (s, token) => String(s || "").split(token || "__none__").join("***").slice(0, 400);

ipcMain.handle("git:clone", async (_e, { url, token }) => {
  url = (url || "").trim();
  if (!/^https:\/\//i.test(url)) return { ok: false, error: "use an https repo URL (https://github.com/owner/repo)" };
  try {
    await fs.promises.mkdir(REPOS_DIR, { recursive: true });
    // Sanitize the derived folder name so a crafted URL (e.g. trailing "..")
    // can't resolve the clone target outside REPOS_DIR.
    let name = (url.split("/").pop() || "repo").replace(/\.git$/, "").replace(/[^\w.-]/g, "");
    if (!name || name === "." || name === "..") name = "repo";
    const dir = path.join(REPOS_DIR, name);
    try { await fs.promises.access(dir); return { ok: false, error: "folder already exists — open it instead: " + dir }; } catch (_) {}
    await git(["clone", authUrl(url, token), dir]);
    try { await git(["-C", dir, "remote", "set-url", "origin", url]); } catch (_) {} // scrub token from stored remote
    return { ok: true, dir, name };
  } catch (e) { return { ok: false, error: scrub(e.stderr || e.message, token) }; }
});
ipcMain.handle("git:pull", async (_e, { dir, token }) => {
  try {
    const remote = (await git(["-C", dir, "remote", "get-url", "origin"])).stdout.trim();
    const r = await git(["-C", dir, "pull", authUrl(remote, token)]);
    return { ok: true, output: scrub(r.stdout || r.stderr || "up to date", token) };
  } catch (e) { return { ok: false, error: scrub(e.stderr || e.message, token) }; }
});
ipcMain.handle("git:log", async (_e, dir) => {
  try { const r = await git(["-C", dir, "log", "--oneline", "-40", "--no-color"]); return { ok: true, commits: r.stdout.trim().split("\n").filter(Boolean) }; }
  catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("git:diff", async (_e, { dir, file }) => {
  try { const r = await git(["-C", dir, "diff", "--no-color"].concat(file ? ["--", file] : [])); return { ok: true, diff: r.stdout || "(no working-tree changes)" }; }
  catch (e) { return { ok: false, error: e.message }; }
});
async function repoFromDir(dir) {
  try { const remote = (await git(["-C", dir, "remote", "get-url", "origin"])).stdout.trim(); const m = remote.match(/github\.com[:/]([^/]+\/[^/.]+?)(?:\.git)?$/i); return m && m[1]; } catch (_) { return null; }
}
async function ghPost(repo, path, token, body) {
  const r = await fetch("https://api.github.com/repos/" + repo + path, { method: "POST", headers: { Accept: "application/vnd.github+json", Authorization: "Bearer " + token, "Content-Type": "application/json", "User-Agent": "Darknode" }, body: JSON.stringify(body) });
  if (!r.ok) { let m = r.status + " " + r.statusText; try { const j = await r.json(); if (j.message) m = j.message; } catch (_) {} throw new Error(m); }
  return r.json();
}
ipcMain.handle("github:createIssue", async (_e, { dir, token, title, body }) => {
  const repo = await repoFromDir(dir);
  if (!repo) return { ok: false, error: "no GitHub remote" };
  if (!token) return { ok: false, error: "set a GitHub token in Settings" };
  try { const d = await ghPost(repo, "/issues", token, { title, body: body || "" }); return { ok: true, number: d.number, url: d.html_url }; }
  catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("github:createPR", async (_e, { dir, token, title, body }) => {
  const repo = await repoFromDir(dir);
  if (!repo) return { ok: false, error: "no GitHub remote" };
  if (!token) return { ok: false, error: "set a GitHub token in Settings" };
  try {
    const head = (await git(["-C", dir, "rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
    const info = await fetch("https://api.github.com/repos/" + repo, { headers: { Authorization: "Bearer " + token, "User-Agent": "Darknode" } }).then((r) => r.json());
    const base = info.default_branch || "main";
    if (head === base) return { ok: false, error: "you're on the base branch (" + base + ") — create a branch first" };
    const d = await ghPost(repo, "/pulls", token, { title, head, base, body: body || "" });
    return { ok: true, number: d.number, url: d.html_url };
  } catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("github:createGist", async (_e, { token, name, content, description, isPublic }) => {
  if (!token) return { ok: false, error: "set a GitHub token in Settings" };
  try {
    const r = await fetch("https://api.github.com/gists", { method: "POST", headers: { Accept: "application/vnd.github+json", Authorization: "Bearer " + token, "Content-Type": "application/json", "User-Agent": "Darknode" }, body: JSON.stringify({ description: description || "", public: !!isPublic, files: { [name || "file.txt"]: { content: content || " " } } }) });
    if (!r.ok) return { ok: false, error: r.status + " " + r.statusText };
    const d = await r.json(); return { ok: true, url: d.html_url };
  } catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("github:comment", async (_e, { dir, token, number, body }) => {
  const repo = await repoFromDir(dir);
  if (!repo) return { ok: false, error: "no GitHub remote" };
  if (!token) return { ok: false, error: "set a GitHub token in Settings" };
  try { const d = await ghPost(repo, "/issues/" + number + "/comments", token, { body }); return { ok: true, url: d.html_url }; }
  catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("git:branches", async (_e, dir) => {
  try {
    const cur = (await git(["-C", dir, "rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
    const b = await git(["-C", dir, "branch", "--format=%(refname:short)"]);
    return { ok: true, current: cur, branches: b.stdout.trim().split("\n").filter(Boolean) };
  } catch (e) { return { ok: false, error: e.message }; }
});
// A branch arg that begins with "-" would be read by git as a flag, not a
// branch (e.g. "-f"/"--force" force-switches and discards the working tree), so
// reject it up front — git() uses execFile, so this is option, not shell, abuse.
const badBranch = (b) => !b || typeof b !== "string" || /^-/.test(b);
ipcMain.handle("git:checkout", async (_e, { dir, branch }) => {
  if (badBranch(branch)) return { ok: false, error: "invalid branch name" };
  try { await git(["-C", dir, "checkout", branch]); return { ok: true }; }
  catch (e) { return { ok: false, error: scrub(e.stderr || e.message) }; }
});
ipcMain.handle("git:checkoutNew", async (_e, { dir, branch }) => {
  if (badBranch(branch)) return { ok: false, error: "invalid branch name" };
  try { await git(["-C", dir, "checkout", "-b", branch]); return { ok: true }; }
  catch (e) { return { ok: false, error: scrub(e.stderr || e.message) }; }
});
ipcMain.handle("github:issues", async (_e, { dir, token }) => {
  let repo;
  try { const remote = (await git(["-C", dir, "remote", "get-url", "origin"])).stdout.trim(); const m = remote.match(/github\.com[:/]([^/]+\/[^/.]+?)(?:\.git)?$/i); repo = m && m[1]; } catch (_) {}
  if (!repo) return { ok: false, error: "no GitHub remote" };
  const h = { Accept: "application/vnd.github+json", "User-Agent": "Darknode" }; if (token) h.Authorization = "Bearer " + token;
  try {
    const [iss, prs] = await Promise.all([
      fetch("https://api.github.com/repos/" + repo + "/issues?state=open&per_page=25", { headers: h }).then((r) => r.ok ? r.json() : []),
      fetch("https://api.github.com/repos/" + repo + "/pulls?state=open&per_page=25", { headers: h }).then((r) => r.ok ? r.json() : []),
    ]);
    return { ok: true, repo, issues: iss.filter((x) => !x.pull_request).map((x) => ({ n: x.number, t: x.title, u: x.user && x.user.login, url: x.html_url })), prs: prs.map((x) => ({ n: x.number, t: x.title, u: x.user && x.user.login, url: x.html_url })) };
  } catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("github:repos", async (_e, token) => {
  if (!token) return { ok: false, error: "no token set" };
  try {
    const r = await fetch("https://api.github.com/user/repos?sort=updated&per_page=100", { headers: { Accept: "application/vnd.github+json", Authorization: "Bearer " + token } });
    if (!r.ok) return { ok: false, error: r.status === 401 ? "bad token" : r.status + " " + r.statusText };
    const data = await r.json();
    return { ok: true, repos: data.map((x) => ({ name: x.full_name, url: x.clone_url, priv: x.private })) };
  } catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("git:status", async (_e, dir) => {
  try {
    const b = await git(["-C", dir, "rev-parse", "--abbrev-ref", "HEAD"]).catch(() => ({ stdout: "" }));
    const st = await git(["-C", dir, "status", "--porcelain"]);
    return { ok: true, branch: b.stdout.trim(), files: st.stdout.trim().split("\n").filter(Boolean) };
  } catch (e) { return { ok: false, error: "not a git repository" }; }
});
ipcMain.handle("git:push", async (_e, { dir, message, token, name, email }) => {
  try {
    await git(["-C", dir, "add", "-A"]);
    try {
      await git(["-C", dir, "-c", "user.name=" + (name || "Darknode"), "-c", "user.email=" + (email || "darknode@local"), "commit", "-m", message || "Update via Darknode"]);
    } catch (e) { if (!/nothing to commit/i.test((e.stdout || "") + (e.stderr || ""))) throw e; }
    const remote = (await git(["-C", dir, "remote", "get-url", "origin"])).stdout.trim();
    const branch = (await git(["-C", dir, "rev-parse", "--abbrev-ref", "HEAD"])).stdout.trim();
    const r = await git(["-C", dir, "push", authUrl(remote, token), "HEAD:" + branch]);
    return { ok: true, output: scrub(r.stderr || r.stdout || "pushed", token) };
  } catch (e) { return { ok: false, error: scrub(e.stderr || e.message, token) }; }
});

// ---- passive subdomain enumeration (Certificate Transparency via crt.sh) ----
ipcMain.handle("subdomains:find", async (_e, domain) => {
  domain = (domain || "").trim().replace(/^https?:\/\//, "").split("/")[0].toLowerCase();
  if (!domain) return { ok: false, error: "no domain" };
  { const g = scope().enforce("subdomains", domain); if (!g.allowed) return { ok: false, blocked: true, error: g.reason }; }
  const ctrl = new AbortController(); const to = setTimeout(() => ctrl.abort(), 20000);
  try {
    const r = await fetch("https://crt.sh/?q=%25." + encodeURIComponent(domain) + "&output=json", { signal: ctrl.signal, headers: { "User-Agent": "Darknode" } });
    const txt = await r.text(); let data;
    try { data = JSON.parse(txt); } catch { return { ok: false, error: "crt.sh is busy — try again in a moment" }; }
    if (!Array.isArray(data)) return { ok: false, error: "crt.sh is busy — try again in a moment" };
    const set = new Set();
    for (const e of data) for (const n of String(e.name_value || "").split("\n")) {
      const s = n.trim().toLowerCase();
      if (s && !s.includes("*") && (s === domain || s.endsWith("." + domain))) set.add(s);
    }
    return { ok: true, domain, subs: [...set].sort() };
  } catch (e) { return { ok: false, error: e.name === "AbortError" ? "crt.sh timed out" : e.message }; }
  finally { clearTimeout(to); }
});

// ---- Workbench filesystem (IDE). Full local FS access — this is a local dev tool. ----
const IGNORE = new Set([".git", "node_modules", ".cache", "__pycache__", ".venv", "dist", ".next"]);
ipcMain.handle("dialog:openFolder", async () => {
  const r = await dialog.showOpenDialog(win, { properties: ["openDirectory"] });
  return r.canceled || !r.filePaths.length ? null : r.filePaths[0];
});
ipcMain.handle("dialog:openFile", async (_e, filters) => {
  const r = await dialog.showOpenDialog(win, { properties: ["openFile"], filters: filters || [] });
  return r.canceled || !r.filePaths.length ? null : r.filePaths[0];
});
ipcMain.handle("fs:list", async (_e, dir) => {
  const target = dir || os.homedir();
  try {
    const ents = await fs.promises.readdir(target, { withFileTypes: true });
    const items = ents
      .filter((d) => !(d.isDirectory() && IGNORE.has(d.name)))
      .map((d) => ({ name: d.name, dir: d.isDirectory(), path: path.join(target, d.name) }))
      .sort((a, b) => (a.dir === b.dir ? a.name.localeCompare(b.name) : a.dir ? -1 : 1));
    return { ok: true, path: target, parent: path.dirname(target), items };
  } catch (e) { return { ok: false, error: e.message, path: target }; }
});
ipcMain.handle("fs:read", async (_e, file) => {
  try {
    const st = await fs.promises.stat(file);
    // Only regular files: a FIFO/device (e.g. /dev/zero, size 0) slips past the
    // size guard and then readFile blocks forever / exhausts memory.
    if (!st.isFile()) return { ok: false, error: "not a regular file" };
    if (st.size > 5e6) return { ok: false, error: "file too large (" + Math.round(st.size / 1e6) + " MB)" };
    return { ok: true, path: file, data: await fs.promises.readFile(file, "utf8") };
  } catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("fs:write", async (_e, { file, data }) => {
  try { await fs.promises.writeFile(file, data, "utf8"); return { ok: true }; }
  catch (e) { return { ok: false, error: e.message }; }
});
// Native file forensics — real hashes/entropy/strings/type over the file bytes.
// Something the web app can only fake; here it runs on the actual file.
ipcMain.handle("forensics:analyze", async (_e, file) => {
  try {
    const st = await fs.promises.stat(file);
    if (!st.isFile()) return { ok: false, error: "not a regular file" };
    if (st.size > 64e6) return { ok: false, error: "file too large (" + Math.round(st.size / 1e6) + " MB, max 64 MB)" };
    const buf = await fs.promises.readFile(file);
    const head = buf.subarray(0, 4096);
    const strings = toolkit.extractStrings(buf, 5).slice(0, 500);
    return {
      ok: true,
      path: file,
      name: path.basename(file),
      size: st.size,
      modified: st.mtime.toISOString(),
      hashes: {
        md5: toolkit.md5(buf),
        sha1: toolkit.sha1(buf),
        sha256: toolkit.sha256(buf),
        crc32: toolkit.crc32Hex(buf),
      },
      entropy: toolkit.entropyVerdict(buf),
      type: toolkit.detectFileType(buf),
      hexdump: toolkit.hexdump(head),
      stringCount: strings.length,
      strings,
    };
  } catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("fs:mkfile", async (_e, { dir, name }) => {
  try { const full = path.join(dir, name); await fs.promises.writeFile(full, "", { flag: "wx" }); return { ok: true, path: full }; }
  catch (e) { return { ok: false, error: e.message }; }
});

// ============================================================
//  QEMU/KVM VM engine — Darknode's own virtual-machine manager.
//  Owns a VM store, creates qcow2 disks, boots via qemu-system-x86_64
//  with KVM acceleration, controls VMs live over QMP, and serves the
//  screen to the renderer via periodic screendumps.
// ============================================================
const VM_DIR = path.join(os.homedir(), ".darknode-vms");
const VM_STORE = path.join(VM_DIR, "vms.json");
const VM_DISKS = path.join(VM_DIR, "disks");
const VM_RUN = path.join(VM_DIR, "run");
const vmProcs = new Map(); // id -> { proc, display, vncPort, qmp }
const QEMU = "qemu-system-x86_64";

function vmEnsureDirs() { for (const d of [VM_DIR, VM_DISKS, VM_RUN]) fs.mkdirSync(d, { recursive: true }); }
function vmReadStore() { try { return JSON.parse(fs.readFileSync(VM_STORE, "utf8")).vms || []; } catch (_) { return []; } }
function vmWriteStore(vms) { vmEnsureDirs(); fs.writeFileSync(VM_STORE, JSON.stringify({ vms }, null, 2)); }
function vmHasKvm() { try { fs.accessSync("/dev/kvm", fs.constants.R_OK | fs.constants.W_OK); return true; } catch (_) { return false; } }
function vmExec(cmd, args, timeout) {
  return new Promise((res) => {
    const p = spawn(cmd, args); let out = "", err = "";
    const to = setTimeout(() => { try { p.kill("SIGKILL"); } catch (_) {} }, timeout || 30000);
    p.stdout.on("data", (d) => (out += d)); p.stderr.on("data", (d) => (err += d));
    p.on("close", (code) => { clearTimeout(to); res({ code, out, err }); });
    p.on("error", (e) => { clearTimeout(to); res({ code: -1, err: e.message }); });
  });
}

// Minimal QMP client: connect, negotiate capabilities, run one command, resolve.
function qmp(sockPath, command, args, timeoutMs) {
  return new Promise((resolve) => {
    const s = net.connect(sockPath);
    let buf = "", phase = "greet", settled = false;
    const done = (v) => { if (settled) return; settled = true; clearTimeout(to); try { s.end(); } catch (_) {} resolve(v); };
    const to = setTimeout(() => done({ error: "qmp timeout" }), timeoutMs || 8000);
    s.on("error", (e) => done({ error: e.message }));
    s.on("data", (d) => {
      buf += d.toString(); let nl;
      while ((nl = buf.indexOf("\n")) >= 0) {
        const line = buf.slice(0, nl).trim(); buf = buf.slice(nl + 1); if (!line) continue;
        let j; try { j = JSON.parse(line); } catch (_) { continue; }
        if (j.QMP && phase === "greet") { phase = "caps"; s.write(JSON.stringify({ execute: "qmp_capabilities" }) + "\n"); continue; }
        if (phase === "caps" && (j.return !== undefined || j.error)) { phase = "cmd"; s.write(JSON.stringify({ execute: command, arguments: args || {} }) + "\n"); continue; }
        if (phase === "cmd" && (j.return !== undefined || j.error)) { done(j.error ? { error: j.error.desc || "qmp error" } : { ok: true, data: j.return }); return; }
      }
    });
  });
}

ipcMain.handle("vm:deps", async () => {
  const q = await vmExec("bash", ["-lc", "command -v " + QEMU + " && command -v qemu-img"], 8000);
  return { qemu: q.code === 0, kvm: vmHasKvm(), qemuPath: (q.out || "").trim().split("\n")[0] || "" };
});
ipcMain.handle("vm:list", () => {
  const vms = vmReadStore();
  return vms.map((v) => ({ ...v, running: vmProcs.has(v.id), vncPort: vmProcs.get(v.id) ? vmProcs.get(v.id).vncPort : null }));
});
// Counts only, for the Deck's usage heartbeat (web shell channel): no names, disks or ISOs.
ipcMain.handle("vm:usage", () => {
  const vms = vmReadStore();
  return { count: vms.length, running: vms.filter((v) => vmProcs.has(v.id)).length, lastStart: vms.reduce((m, v) => Math.max(m, Number(v.lastStarted) || 0), 0) };
});
ipcMain.handle("vm:create", async (_e, { name, memMB, cpus, diskGB, iso }) => {
  vmEnsureDirs();
  name = (name || "vm").replace(/[^\w.-]/g, "_").slice(0, 40) || "vm";
  const id = "vm" + Date.now().toString(36);
  const disk = path.join(VM_DISKS, id + ".qcow2");
  const r = await vmExec("qemu-img", ["create", "-f", "qcow2", disk, Math.max(1, Math.min(512, parseInt(diskGB, 10) || 20)) + "G"], 30000);
  if (r.code !== 0) return { ok: false, error: (r.err || "qemu-img failed").trim() };
  const vms = vmReadStore();
  const vm = { id, name, memMB: Math.max(256, Math.min(65536, parseInt(memMB, 10) || 2048)), cpus: Math.max(1, Math.min(32, parseInt(cpus, 10) || 2)), disk, iso: iso || "", created: Date.now() };
  vms.push(vm); vmWriteStore(vms);
  return { ok: true, vm };
});
ipcMain.handle("vm:update", (_e, { id, patch }) => {
  const vms = vmReadStore(); const v = vms.find((x) => x.id === id); if (!v) return { ok: false, error: "no such vm" };
  // Only metadata is renderer-patchable. Never let a patch rewrite `disk` (it
  // becomes the QEMU -drive file=), `id` or `created`. memMB/cpus are clamped
  // to the same bounds as creation.
  const p = patch || {};
  if (typeof p.name === "string") v.name = p.name.replace(/[^\w.-]/g, "_").slice(0, 40) || v.name;
  if ("iso" in p) v.iso = String(p.iso || "");
  if (p.memMB != null) v.memMB = Math.max(256, Math.min(65536, parseInt(p.memMB, 10) || v.memMB));
  if (p.cpus != null) v.cpus = Math.max(1, Math.min(32, parseInt(p.cpus, 10) || v.cpus));
  vmWriteStore(vms); return { ok: true, vm: v };
});
ipcMain.handle("vm:delete", async (_e, { id, deleteDisk }) => {
  if (vmProcs.has(id)) { try { vmProcs.get(id).proc.kill("SIGKILL"); } catch (_) {} vmProcs.delete(id); }
  const vms = vmReadStore(); const v = vms.find((x) => x.id === id);
  if (v && deleteDisk) { try { fs.unlinkSync(v.disk); } catch (_) {} }
  vmWriteStore(vms.filter((x) => x.id !== id)); return { ok: true };
});
ipcMain.handle("vm:start", async (_e, { id }) => {
  if (vmProcs.has(id)) return { ok: true, already: true, vncPort: vmProcs.get(id).vncPort };
  const vms = vmReadStore(); const v = vms.find((x) => x.id === id); if (!v) return { ok: false, error: "no such vm" };
  vmEnsureDirs();
  const used = new Set([...vmProcs.values()].map((r) => r.display));
  let display = 0; while (used.has(display) && display < 64) display++;
  const qmpPath = path.join(VM_RUN, id + ".qmp");
  try { fs.unlinkSync(qmpPath); } catch (_) {}
  const args = ["-name", v.name, "-m", String(v.memMB), "-smp", String(v.cpus),
    "-drive", "file=" + v.disk + ",format=qcow2,if=virtio",
    "-vnc", "127.0.0.1:" + display,
    "-qmp", "unix:" + qmpPath + ",server,nowait",
    "-usb", "-device", "usb-tablet",
    "-netdev", "user,id=n0", "-device", "virtio-net,netdev=n0"];
  if (vmHasKvm()) args.unshift("-enable-kvm", "-cpu", "host");
  if (v.iso) { args.push("-cdrom", v.iso, "-boot", "menu=on,order=dc"); }
  let proc;
  try { proc = spawn(QEMU, args, { stdio: ["ignore", "pipe", "pipe"] }); }
  catch (e) { return { ok: false, error: e.message }; }
  let earlyErr = "";
  proc.stderr.on("data", (d) => (earlyErr += d.toString()));
  proc.on("exit", () => { vmProcs.delete(id); toUi("vm:exit", { id }); });
  const rec = { proc, display, vncPort: 5900 + display, qmp: qmpPath };
  vmProcs.set(id, rec);
  // give QEMU a moment; if it died immediately, report the error
  await new Promise((r) => setTimeout(r, 700));
  if (proc.exitCode !== null) {
    vmProcs.delete(id);
    let err = (earlyErr || "QEMU exited on launch").trim();
    if (/Failed to get "?write"? lock|Is another process using the image/i.test(err)) err = "This VM's disk is already in use by another running instance. Stop that one first, or reboot to clear a stale lock.";
    else if (/Could not access KVM|Permission denied.*kvm|\/dev\/kvm/i.test(err)) err = "Can't access /dev/kvm. Add yourself to the 'kvm' group (sudo usermod -aG kvm $USER) and log out/in.";
    return { ok: false, error: err.slice(0, 400) };
  }
  try { const all = vmReadStore(); const me = all.find((x) => x.id === id); if (me) { me.lastStarted = Date.now(); vmWriteStore(all); } } catch (_) {}
  return { ok: true, vncPort: rec.vncPort, display };
});
ipcMain.handle("vm:stop", async (_e, { id, force }) => {
  const r = vmProcs.get(id); if (!r) return { ok: true, note: "not running" };
  if (force) { try { r.proc.kill("SIGKILL"); } catch (_) {} vmProcs.delete(id); return { ok: true }; }
  const res = await qmp(r.qmp, "system_powerdown", {}, 5000);
  if (res.error) { try { r.proc.kill("SIGTERM"); } catch (_) {} }
  return { ok: true };
});
ipcMain.handle("vm:reset", async (_e, { id }) => { const r = vmProcs.get(id); if (!r) return { ok: false }; return await qmp(r.qmp, "system_reset", {}, 5000); });
ipcMain.handle("vm:key", async (_e, { id, keys }) => {
  const r = vmProcs.get(id); if (!r) return { ok: false, error: "not running" };
  const arr = (keys || []).map((k) => ({ type: "qcode", data: k }));
  return await qmp(r.qmp, "send-key", { keys: arr }, 5000);
});
ipcMain.handle("vm:mouse", async (_e, { id, x, y, down, up }) => {
  const r = vmProcs.get(id); if (!r) return { ok: false, error: "not running" };
  const events = [
    { type: "abs", data: { axis: "x", value: Math.max(0, Math.min(32767, Math.round((x || 0) * 32767))) } },
    { type: "abs", data: { axis: "y", value: Math.max(0, Math.min(32767, Math.round((y || 0) * 32767))) } },
  ];
  if (down) events.push({ type: "btn", data: { button: "left", down: true } });
  if (up) events.push({ type: "btn", data: { button: "left", down: false } });
  return await qmp(r.qmp, "input-send-event", { events }, 5000);
});
ipcMain.handle("vm:screendump", async (_e, { id }) => {
  const r = vmProcs.get(id); if (!r) return { ok: false, error: "not running" };
  const png = path.join(VM_RUN, id + ".png");
  const res = await qmp(r.qmp, "screendump", { filename: png, format: "png" }, 6000);
  if (res.error) {
    const ppm = path.join(VM_RUN, id + ".ppm");
    const r2 = await qmp(r.qmp, "screendump", { filename: ppm }, 6000);
    if (r2.error) return { ok: false, error: r2.error };
    try {
      const buf = fs.readFileSync(ppm);
      // parse P6 PPM: "P6\n<w> <h>\n255\n<rgb bytes>"
      // Bounds-checked tokenizer: a truncated/empty PPM must not spin the main
      // event loop forever (buf[p] === undefined would otherwise never match a
      // delimiter). Each loop stops at end-of-buffer.
      let p = 0; const tok = () => { while (p < buf.length && (buf[p] === 0x20 || buf[p] === 0x0a || buf[p] === 0x09 || buf[p] === 0x0d)) p++; let s = p; while (p < buf.length && buf[p] !== 0x20 && buf[p] !== 0x0a && buf[p] !== 0x09 && buf[p] !== 0x0d) p++; return buf.slice(s, p).toString(); };
      if (tok() !== "P6") return { ok: false, error: "bad ppm" };
      const w = +tok(), h = +tok(); tok(); p++; // skip maxval + single whitespace
      if (!Number.isInteger(w) || !Number.isInteger(h) || w <= 0 || h <= 0 || w * h > 33_000_000) return { ok: false, error: "bad ppm" };
      const rgb = buf.slice(p); const bgra = Buffer.alloc(w * h * 4);
      for (let i = 0, j = 0; i < w * h; i++) { bgra[j] = rgb[i * 3 + 2]; bgra[j + 1] = rgb[i * 3 + 1]; bgra[j + 2] = rgb[i * 3]; bgra[j + 3] = 255; j += 4; }
      const { nativeImage } = require("electron");
      const img = nativeImage.createFromBitmap(bgra, { width: w, height: h });
      return { ok: true, data: img.toDataURL() };
    } catch (e) { return { ok: false, error: e.message }; }
  }
  try { const b = fs.readFileSync(png); return { ok: true, data: "data:image/png;base64," + b.toString("base64") }; }
  catch (e) { return { ok: false, error: e.message }; }
});
// ---------- MCP (Model Context Protocol) client: stdio + HTTP(JSON-RPC/SSE) ----------
// Dependency-free JSON-RPC 2.0 over newline-delimited stdio OR HTTP POST. Supports tools, resources,
// prompts, lifecycle (auto-reconnect + tools/list_changed), and server->client sampling routed to local Ollama.
const mcpServers = new Map(); // name -> session
const mcpRetry = new Map();    // name -> reconnect attempt count (survives the per-connect session object)
const MCP_PROTO = "2024-11-05";
let MCP_SAMPLE_MODEL = "hermes3"; // model used to answer MCP sampling requests

function mcpCleanup(name, byUser) {
  const s = mcpServers.get(name);
  if (!s) return;
  if (byUser) { s.closedByUser = true; mcpRetry.delete(name); }
  if (s.reconnectTimer) { clearTimeout(s.reconnectTimer); s.reconnectTimer = null; }
  for (const p of s.pending.values()) { try { p.reject(new Error("disconnected")); } catch (_) {} }
  s.pending.clear();
  try { if (s.proc) s.proc.kill("SIGKILL"); } catch (_) {}
  mcpServers.delete(name);
}
function mcpSend(s, msg) { try { s.proc.stdin.write(JSON.stringify(msg) + "\n"); } catch (_) {} }
function mcpHttpPost(s, body) {
  return new Promise((resolve, reject) => {
    let u; try { u = new URL(s.url); } catch (e) { return reject(e); }
    const mod = u.protocol === "https:" ? https : http;
    const data = JSON.stringify(body);
    const headers = Object.assign({ "Content-Type": "application/json", "Accept": "application/json, text/event-stream", "Content-Length": Buffer.byteLength(data) }, s.headers || {});
    if (s.sessionId) headers["Mcp-Session-Id"] = s.sessionId;
    const req = mod.request({ hostname: u.hostname, port: u.port || (u.protocol === "https:" ? 443 : 80), path: u.pathname + u.search, method: "POST", headers }, (res) => {
      const sid = res.headers["mcp-session-id"]; if (sid) s.sessionId = sid;
      const ct = res.headers["content-type"] || ""; let buf = "";
      res.on("data", (c) => (buf += c)); res.on("end", () => resolve({ status: res.statusCode, ct, buf }));
    });
    req.on("error", reject); req.write(data); req.end();
  });
}
function mcpParseMessages(ct, buf) {
  if (/event-stream/.test(ct)) { const out = []; for (const line of buf.split(/\r?\n/)) { const m = line.match(/^data:\s?(.*)$/); if (m) { try { out.push(JSON.parse(m[1])); } catch (_) {} } } return out; }
  try { const j = JSON.parse(buf); return Array.isArray(j) ? j : [j]; } catch (_) { return []; }
}
function mcpLocalSample(params) {
  return new Promise((resolve, reject) => {
    const msgs = (params.messages || []).map((m) => ({ role: m.role === "assistant" ? "assistant" : "user", content: (m.content && (m.content.text != null ? m.content.text : (typeof m.content === "string" ? m.content : JSON.stringify(m.content)))) || "" }));
    if (params.systemPrompt) msgs.unshift({ role: "system", content: params.systemPrompt });
    const data = JSON.stringify({ model: MCP_SAMPLE_MODEL, stream: false, messages: msgs, options: { temperature: params.temperature != null ? params.temperature : 0.7 } });
    const req = http.request({ host: "127.0.0.1", port: 11434, path: "/api/chat", method: "POST", headers: { "Content-Type": "application/json" } }, (res) => { let b = ""; res.on("data", (c) => (b += c)); res.on("end", () => { try { const j = JSON.parse(b); resolve({ role: "assistant", content: { type: "text", text: (j.message && j.message.content) || "" }, model: MCP_SAMPLE_MODEL, stopReason: "endTurn" }); } catch (e) { reject(e); } }); });
    req.on("error", reject); req.write(data); req.end();
  });
}
async function mcpHandleServerRequest(s, msg) {
  let result, error;
  try {
    if (msg.method === "sampling/createMessage") result = await mcpLocalSample(msg.params || {});
    else if (msg.method === "roots/list") result = { roots: s.roots || [] };
    else if (msg.method === "ping") result = {};
    else error = { code: -32601, message: "method not supported: " + msg.method };
  } catch (e) { error = { code: -32603, message: e.message }; }
  const reply = error ? { jsonrpc: "2.0", id: msg.id, error } : { jsonrpc: "2.0", id: msg.id, result };
  if (s.transport === "http") mcpHttpPost(s, reply).catch(() => {}); else mcpSend(s, reply);
}
function mcpDispatch(s, msg) {
  if (!msg || typeof msg !== "object") return;
  if (msg.method) {
    if (msg.id != null) { mcpHandleServerRequest(s, msg); return; }           // server -> client request
    if (msg.method === "notifications/tools/list_changed") mcpRefreshTools(s); // notification
    return;
  }
  if (msg.id != null && s.pending.has(msg.id)) { const p = s.pending.get(msg.id); s.pending.delete(msg.id); if (msg.error) p.reject(new Error(msg.error.message || "MCP error")); else p.resolve(msg.result); }
}
function mcpOnData(s, chunk) {
  s.buf += chunk.toString(); let nl;
  while ((nl = s.buf.indexOf("\n")) >= 0) { const line = s.buf.slice(0, nl).trim(); s.buf = s.buf.slice(nl + 1); if (!line) continue; let msg; try { msg = JSON.parse(line); } catch (_) { continue; } mcpDispatch(s, msg); }
}
async function mcpRequest(s, method, params, timeout) {
  if (s.transport === "http") {
    const id = s.nextId++;
    const { status, ct, buf } = await mcpHttpPost(s, { jsonrpc: "2.0", id, method, params: params || {} });
    if (status >= 400) throw new Error("HTTP " + status + ": " + String(buf).slice(0, 200));
    const msgs = mcpParseMessages(ct, buf); let result, err, seen = false;
    for (const m of msgs) { if (m && m.id === id) { seen = true; if (m.error) err = m.error; else result = m.result; } else mcpDispatch(s, m); }
    if (err) throw new Error(err.message || "MCP error");
    if (!seen && method !== "initialize") return result;
    return result;
  }
  return new Promise((resolve, reject) => {
    const id = s.nextId++; s.pending.set(id, { resolve, reject });
    mcpSend(s, { jsonrpc: "2.0", id, method, params: params || {} });
    setTimeout(() => { if (s.pending.has(id)) { s.pending.delete(id); reject(new Error("MCP request timed out: " + method)); } }, timeout || 30000);
  });
}
function mcpNotify(s, method, params) { if (s.transport === "http") mcpHttpPost(s, { jsonrpc: "2.0", method, params: params || {} }).catch(() => {}); else mcpSend(s, { jsonrpc: "2.0", method, params: params || {} }); }
async function mcpRefreshTools(s) { try { const tl = await mcpRequest(s, "tools/list", {}, 20000); s.tools = (tl && tl.tools) || []; } catch (_) {} }
function mcpScheduleReconnect(s) {
  if (s.closedByUser || s.reconnectTimer) return;
  // Exponential backoff with a cap, and give up after a few tries, so a server that
  // crashes on launch can't respawn every 3s forever. Reset on a successful connect.
  const n = (mcpRetry.get(s.name) || 0) + 1; mcpRetry.set(s.name, n);
  if (n > 8) return;
  const delay = Math.min(3000 * 2 ** (n - 1), 60000);
  s.reconnectTimer = setTimeout(() => { s.reconnectTimer = null; if (!s.closedByUser) mcpConnect(s.cfg).catch(() => {}); }, delay);
}
async function mcpConnect(cfg) {
  const name = cfg && cfg.name; if (!name) return { ok: false, error: "name is required" };
  const transport = cfg.transport === "http" ? "http" : "stdio";
  mcpCleanup(name);
  const s = { name, cfg, transport, buf: "", nextId: 1, pending: new Map(), tools: [], resources: [], prompts: [], info: null, caps: {}, roots: cfg.roots || [], closedByUser: false, spawnErr: "" };
  if (transport === "http") {
    if (!cfg.url) return { ok: false, error: "url is required for http transport" };
    s.url = cfg.url; s.headers = cfg.headers || {};
  } else {
    if (!cfg.command) return { ok: false, error: "command is required for stdio transport" };
    let proc; try { proc = spawn(cfg.command, cfg.args || [], { env: Object.assign({}, process.env, cfg.env || {}), stdio: ["pipe", "pipe", "pipe"] }); } catch (e) { return { ok: false, error: e.message }; }
    s.proc = proc;
    proc.stdout.setEncoding("utf8"); proc.stderr.setEncoding("utf8"); // decode JSON-RPC across chunk boundaries (multibyte payloads are not split)
    proc.stderr.on("data", (d) => { s.spawnErr = (s.spawnErr + d).slice(-600); });
    proc.stdout.on("data", (d) => mcpOnData(s, d));
    proc.on("error", (e) => { for (const p of s.pending.values()) p.reject(e); s.pending.clear(); });
    proc.on("exit", () => { for (const p of s.pending.values()) p.reject(new Error("MCP server exited")); s.pending.clear(); if (!s.closedByUser) mcpScheduleReconnect(s); });
  }
  mcpServers.set(name, s);
  try {
    const init = await mcpRequest(s, "initialize", { protocolVersion: MCP_PROTO, capabilities: { sampling: {}, roots: { listChanged: false } }, clientInfo: { name: "Darknode", version: app.getVersion() } }, 20000);
    s.info = (init && init.serverInfo) || null; s.caps = (init && init.capabilities) || {};
    mcpNotify(s, "notifications/initialized", {});
    mcpRetry.delete(name); // connected — clear the backoff counter
    await mcpRefreshTools(s);
    try { if (s.caps.resources) { const r = await mcpRequest(s, "resources/list", {}, 15000); s.resources = (r && r.resources) || []; } } catch (_) {}
    try { if (s.caps.prompts) { const r = await mcpRequest(s, "prompts/list", {}, 15000); s.prompts = (r && r.prompts) || []; } } catch (_) {}
    return { ok: true, name, tools: s.tools, resources: s.resources, prompts: s.prompts, info: s.info };
  } catch (e) { const err = (e.message || "connect failed") + (s.spawnErr ? " :: " + s.spawnErr : ""); mcpCleanup(name); return { ok: false, error: err }; }
}
ipcMain.handle("mcp:connect", (_e, cfg) => mcpConnect(cfg || {}));
ipcMain.handle("mcp:list", () => ({ ok: true, servers: [...mcpServers.entries()].map(([name, s]) => ({ name, info: s.info, transport: s.transport, tools: s.tools, resources: s.resources, prompts: s.prompts })) }));
ipcMain.handle("mcp:call", async (_e, { server, tool, args }) => {
  const s = mcpServers.get(server); if (!s) return { ok: false, error: "MCP server not connected: " + server };
  try {
    const r = await mcpRequest(s, "tools/call", { name: tool, arguments: args || {} }, 120000);
    const text = Array.isArray(r && r.content) ? r.content.map((c) => (c && c.text != null ? c.text : (c && c.type === "image" ? "[image]" : JSON.stringify(c)))).join("\n") : JSON.stringify(r);
    return { ok: true, isError: !!(r && r.isError), content: text };
  } catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("mcp:readResource", async (_e, { server, uri }) => {
  const s = mcpServers.get(server); if (!s) return { ok: false, error: "not connected: " + server };
  try { const r = await mcpRequest(s, "resources/read", { uri }, 60000); const text = Array.isArray(r && r.contents) ? r.contents.map((c) => c.text != null ? c.text : (c.blob != null ? "[binary]" : JSON.stringify(c))).join("\n") : JSON.stringify(r); return { ok: true, content: text }; }
  catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("mcp:getPrompt", async (_e, { server, name, args }) => {
  const s = mcpServers.get(server); if (!s) return { ok: false, error: "not connected: " + server };
  try { const r = await mcpRequest(s, "prompts/get", { name, arguments: args || {} }, 60000); return { ok: true, prompt: r }; }
  catch (e) { return { ok: false, error: e.message }; }
});
ipcMain.handle("mcp:sampleModel", (_e, model) => { if (model) MCP_SAMPLE_MODEL = String(model); return { ok: true, model: MCP_SAMPLE_MODEL }; });
ipcMain.handle("mcp:disconnect", (_e, name) => { mcpCleanup(name, true); return { ok: true }; });
ipcMain.handle("mcp:status", () => ({ ok: true, connected: [...mcpServers.keys()] }));

app.on("before-quit", () => {
  _quitting = true;
  for (const r of vmProcs.values()) { try { r.proc.kill("SIGKILL"); } catch (_) {} }
  for (const p of procs.values()) { try { p.kill(); } catch (_) {} }   // streamed `run` children
  for (const p of ptys.values()) { try { p.kill(); } catch (_) {} }     // open terminal PTYs
  for (const s of mcpServers.values()) { s.closedByUser = true; if (s.reconnectTimer) { try { clearTimeout(s.reconnectTimer); } catch (_) {} } try { if (s.proc) s.proc.kill("SIGKILL"); } catch (_) {} }
});