poltertab 1.9.0 → 1.10.0-beta.2

package/bin/uploads.js

@@ -0,0 +1,294 @@
+"use strict";
+
+// poltertab uploads — manage the upload allowlist and view the activity log.
+// Works with no server or extension running; edits config.json directly.
+
+const os = require("os");
+const {
+  getAllowlist,
+  addAllowlistEntry,
+  removeAllowlistEntry,
+  addTrustedExtensionId,
+  getTrustedExtensionIds,
+  removeTrustedExtensionId,
+} = require("../mcp-server/uploads-config.js");
+const { getRecentLog } = require("../mcp-server/uploads-log.js");
+const { validateAllowlistEntry, buildAlwaysBlocked } = require("../mcp-server/upload-paths.js");
+const {
+  resolveWsPort,
+  tryConnectToServer,
+  probeIsPoltertab,
+  pairViaRunningServer,
+  pairViaTempListener,
+} = require("./pair-flow.js");
+
+async function run(argv) {
+  const sub = argv[0];
+
+  if (!sub || sub === "list") {
+    const homeDir = os.homedir();
+    const allowlist = getAllowlist();
+    const alwaysBlocked = buildAlwaysBlocked(homeDir);
+
+    console.log("\nUpload configuration (~/.poltertab/config.json)");
+    console.log("─".repeat(50));
+
+    if (allowlist.length === 0) {
+      console.log("\n  Allowed folders: (none — uploads disabled)");
+    } else {
+      console.log("\n  Allowed folders:");
+      for (const dir of allowlist) {
+        console.log(`    + ${dir}`);
+      }
+    }
+
+    console.log("\n  Always blocked (cannot be changed):");
+    for (const dir of alwaysBlocked) {
+      console.log(`    ✗ ${dir}`);
+    }
+    console.log(`    ✗ ~/.*  (home dotfiles)`);
+    console.log();
+    return;
+  }
+
+  if (sub === "allow") {
+    const dir = argv[1];
+    if (!dir) {
+      console.error("Usage: poltertab uploads allow <dir>");
+      process.exit(1);
+    }
+    const v = validateAllowlistEntry(dir);
+    if (!v.ok) {
+      console.error(`\n  Error: ${v.errorText}\n`);
+      process.exit(1);
+    }
+    const added = addAllowlistEntry(dir);
+    if (added) {
+      console.log(`\n  Added: ${dir}\n`);
+    } else {
+      console.log(`\n  Already present: ${dir}\n`);
+    }
+    return;
+  }
+
+  if (sub === "revoke") {
+    const dir = argv[1];
+    if (!dir) {
+      console.error("Usage: poltertab uploads revoke <dir>");
+      process.exit(1);
+    }
+    const removed = removeAllowlistEntry(dir);
+    if (removed) {
+      console.log(`\n  Removed: ${dir}\n`);
+    } else {
+      console.log(`\n  Not found in allowlist: ${dir}\n`);
+    }
+    return;
+  }
+
+  if (sub === "log") {
+    let n = 20;
+    const nIdx = argv.indexOf("-n");
+    if (nIdx !== -1 && argv[nIdx + 1]) {
+      n = parseInt(argv[nIdx + 1], 10) || 20;
+    }
+    const entries = getRecentLog(n);
+    if (entries.length === 0) {
+      console.log("\n  No upload activity recorded.\n");
+      return;
+    }
+    console.log(`\nUpload activity log (last ${entries.length} entries)`);
+    console.log("─".repeat(50));
+    for (const e of entries) {
+      const paths = Array.isArray(e.paths) ? e.paths.join(", ") : String(e.paths);
+      console.log(`  ${e.ts}  [${e.outcome}]  method=${e.method}  ${paths}`);
+    }
+    console.log();
+    return;
+  }
+
+  if (sub === "pair") {
+    await runPair(argv.slice(1));
+    return;
+  }
+
+  if (sub === "unpair") {
+    await runUnpair(argv.slice(1));
+    return;
+  }
+
+  console.error(`\n  Unknown subcommand: ${sub}`);
+  console.error("  Usage: poltertab uploads list|allow <dir>|revoke <dir>|log [-n N]|pair [--id <id>]|unpair [--id <id>]\n");
+  process.exit(1);
+}
+
+// (pair primitives live in pair-flow.js and are imported above)
+
+// ── poltertab uploads pair ─────────────────────────────────────────────────
+
+async function runPair(argv) {
+  // --id is kept for backward compatibility: pair by bare extension ID directly.
+  const idFlagIdx = argv.indexOf("--id");
+  const flagId = idFlagIdx !== -1 ? argv[idFlagIdx + 1] : null;
+
+  if (flagId) {
+    if (!/^[a-p]{32}$/.test(flagId)) {
+      console.error(`\nInvalid extension ID: ${flagId}`);
+      console.error("Chrome extension IDs are 32 lowercase letters (a-p).\n");
+      process.exit(1);
+    }
+    const added = addTrustedExtensionId(flagId);
+    if (added) {
+      console.log(`\n  Paired: ${flagId}`);
+      console.log("  Upload config access is now enabled for this extension.");
+      console.log(`  (undo: poltertab uploads unpair ${flagId})\n`);
+    } else {
+      console.log(`\n  Already paired: ${flagId}\n`);
+    }
+    return;
+  }
+
+  if (!process.stdin.isTTY) {
+    console.error("\nError: poltertab uploads pair requires an interactive terminal.\n" +
+      "Use --id <extension-id> to pair non-interactively.\n");
+    process.exit(1);
+  }
+
+  const readline = require("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const port = resolveWsPort();
+
+  let serverWs = null;
+  try {
+    serverWs = await tryConnectToServer(port);
+    // Verify the server is actually poltertab, not an unrelated WS server.
+    if (!(await probeIsPoltertab(port))) {
+      serverWs.terminate();
+      serverWs = null;
+      rl.close();
+      console.error(
+        `\n  Port ${port} is in use by something that isn't poltertab.` +
+        " Close it or set a different port in ~/.poltertab/config.json, then retry.\n",
+      );
+      process.exit(1);
+    }
+  } catch (err) {
+    if (err.code === "ETIMEDOUT") {
+      rl.close();
+      console.error(
+        `\n  Port ${port} is in use by something that isn't poltertab.` +
+        " Close it or set a different port in ~/.poltertab/config.json, then retry.\n",
+      );
+      process.exit(1);
+    }
+    if (err.code !== "ECONNREFUSED" && err.code !== "ENOENT") {
+      rl.close();
+      console.error(`\nCould not connect to port ${port}: ${err.message}\n`);
+      process.exit(1);
+    }
+    // Nothing listening — start temp listener.
+  }
+
+  let result;
+  if (serverWs) {
+    result = await pairViaRunningServer(serverWs, rl);
+  } else {
+    console.log(
+      `\n  No poltertab server found. Starting a temporary pairing listener on port ${port}.`,
+    );
+    console.log("  Open the extension popup — it will connect automatically and show a 4-letter code.\n");
+    process.stdout.write("  waiting for the extension to connect…\n");
+
+    try {
+      result = await pairViaTempListener(port, rl, {
+        onStatus: (msg) => process.stdout.write(`  ${msg}\n`),
+      });
+    } catch (err) {
+      rl.close();
+      if (err.code === "EADDRINUSE") {
+        console.error(
+          `\n  Port ${port} is in use by something that isn't poltertab.` +
+          " Close it or set a different port in ~/.poltertab/config.json, then retry.\n",
+        );
+      } else {
+        console.error(`\n  Failed to start pairing listener: ${err.message}\n`);
+      }
+      process.exit(1);
+    }
+  }
+
+  rl.close();
+
+  if (result.ok) {
+    const shortId = result.extensionId.slice(0, 8);
+    console.log(
+      `\n  ✓ paired               extension ${shortId}… · uploads panel is live in the extension`,
+    );
+    console.log(`  (undo: poltertab uploads unpair ${result.extensionId})\n`);
+  } else if (result.reason === "skipped") {
+    console.log("\n  – pairing skipped      run poltertab uploads pair once the extension is loaded\n");
+  } else if (result.reason === "locked") {
+    console.error("\n  Too many wrong codes. Pairing is locked for 15 minutes.\n");
+    process.exit(1);
+  } else if (result.reason === "config_write_failed") {
+    process.exit(1);
+  }
+}
+
+// ── poltertab uploads unpair ───────────────────────────────────────────────
+
+async function runUnpair(argv) {
+  // Accept positional id: `poltertab uploads unpair <id>` (the form success hints print).
+  // Also accept --id <id> for backward compatibility.
+  const idFlagIdx = argv.indexOf("--id");
+  const flagId = idFlagIdx !== -1 ? argv[idFlagIdx + 1] : null;
+  const positionalId = !flagId && argv.length > 0 && !argv[0].startsWith("-") ? argv[0] : null;
+  const targetId = flagId || positionalId;
+
+  if (targetId) {
+    const removed = removeTrustedExtensionId(targetId);
+    if (removed) {
+      console.log(`\n  Unpaired: ${targetId}\n`);
+    } else {
+      console.log(`\n  Not found in paired extensions: ${targetId}\n`);
+    }
+    return;
+  }
+
+  // No-id form: list all paired ids, require TTY + y/n confirmation before removing.
+  const ids = getTrustedExtensionIds();
+  if (ids.length === 0) {
+    console.log("\n  No extensions are currently paired.\n");
+    return;
+  }
+
+  if (!process.stdin.isTTY) {
+    console.error(
+      "\n  'poltertab uploads unpair' with no id requires an interactive terminal.\n" +
+      "  Pass the extension id to remove a specific one: poltertab uploads unpair <id>\n",
+    );
+    process.exit(1);
+  }
+
+  console.log("\n  Currently paired extensions:");
+  for (const id of ids) console.log(`    ${id}`);
+  console.log();
+
+  const readline = require("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  await new Promise((resolve) => {
+    rl.question("  Remove ALL paired extensions? [y/N] ", (ans) => {
+      rl.close();
+      if ((ans || "").trim().toLowerCase() === "y") {
+        for (const id of ids) removeTrustedExtensionId(id);
+        console.log(`\n  Unpaired ${ids.length} extension${ids.length === 1 ? "" : "s"}.\n`);
+      } else {
+        console.log("\n  Cancelled.\n");
+      }
+      resolve();
+    });
+  });
+}
+
+module.exports = { run };

package/mcp-server/bridge.js

@@ -35,9 +35,45 @@ const {
 } = require("./config.js");
 const updates = require("./update-check.js");
 const OWN_VERSION = require("./../package.json").version;
+const { getAllowlist, addAllowlistEntry, removeAllowlistEntry, getTrustedExtensionIds, addTrustedExtensionId } = require("./uploads-config.js");
+const { PairHost } = require("./pair-host.js");
+const { logUpload, getRecentLog } = require("./uploads-log.js");
+const { buildAlwaysBlocked, validateAllowlistEntry } = require("./upload-paths.js");
+const fs = require("fs");
+const path = require("path");
+
+// ── Trusted extension IDs ─────────────────────────────────────────────────
+// Upload config/log WS messages are restricted to origins paired via
+// `poltertab uploads pair`. The CWS-assigned ID will go here once the Store
+// publishes the extension; until then it is an empty string (unused).
+//
+// Caveat (design §4): a non-browser local process can forge any Origin header;
+// this gate stops other Chrome extensions, not a hostile process with raw socket
+// access. The always-blocked list and allowlist are the server-side guards.
+const CWS_EXTENSION_ID = ""; // filled when the Chrome Web Store assigns it
+
+// isUploadsAuthorized and isPaired may throw on malformed config.json —
+// callers must catch and send uploads_error.
+function isUploadsAuthorized(origin) {
+  if (!origin || !origin.startsWith("chrome-extension://")) return false;
+  const id = origin.slice("chrome-extension://".length).replace(/\/$/, "");
+  const ids = new Set(getTrustedExtensionIds());
+  if (CWS_EXTENSION_ID) ids.add(CWS_EXTENSION_ID);
+  return ids.has(id);
+}
+
+function isPaired() {
+  const ids = new Set(getTrustedExtensionIds());
+  if (CWS_EXTENSION_ID) ids.add(CWS_EXTENSION_ID);
+  return ids.size > 0;
+}
 
 let WS_PORT = resolvePort();
 
+// Manages in-memory pair codes for the current Primary session. Null when this
+// node is a Secondary (Secondary never generates codes; the Primary does).
+let pairHost = null;
+
 // Populated when the extension connects; stays null until then, which is itself
 // worth reporting — a skew warning must not fire on "no extension yet".
 let extensionVersion = null;
@@ -270,6 +306,7 @@ function allowOrigin(info, cb) {
 }
 
 function setupPrimaryServer() {
+  pairHost = new PairHost();
   const http = require("http");
   const LOOPBACK = new Set(["127.0.0.1", "::1", "::ffff:127.0.0.1"]);
   // The source address alone does not stop DNS rebinding: a page at
@@ -841,8 +878,9 @@ function _dispatchProxyNow(callerWs, id, action, params) {
 }
 
 function setupPrimaryWss(wss) {
-  wss.on("connection", (ws) => {
+  wss.on("connection", (ws, req) => {
     ws.isAlive = true;
+    ws.handshakeOrigin = (req && req.headers && req.headers.origin) || null;
     ws.supportsNewCloseCodes = false;
     ws.on("pong", () => {
       ws.isAlive = true;
@@ -954,6 +992,28 @@ function setupPrimaryWss(wss) {
             broadcastSessionState();
           }
 
+          // Self-navigation guard: refuse commands targeting extension pages.
+          const EXTENSION_SENSITIVE_ACTIONS = new Set([
+            "navigate", "tab_new", "click", "fill", "snapshot", "scrape", "extract",
+          ]);
+          if (EXTENSION_SENSITIVE_ACTIONS.has(action)) {
+            const urlParam = params.url || params.target || "";
+            let isSelfNav = false;
+            if (typeof urlParam === "string" && urlParam) {
+              try { isSelfNav = new URL(urlParam).protocol.toLowerCase() === "chrome-extension:"; } catch (_) {}
+            }
+            if (isSelfNav) {
+              if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                  id,
+                  success: false,
+                  error: "[self_navigation_refused] Agent commands cannot target extension pages.",
+                }));
+              }
+              return;
+            }
+          }
+
           if (action === "get_network_state") {
             (async () => {
               try {
@@ -1097,10 +1157,193 @@ function setupPrimaryWss(wss) {
                 // A socket that died mid-handshake reconnects on its own.
               }
             }
+            // Push a pair code to unpaired extensions so the UI can display it
+            // without the user running any CLI command first.
+            // Per-origin check: an already-trusted extension must not receive a code.
+            if (pairHost && ws.handshakeOrigin && !pairHost._socketCodes.has(ws) && !isUploadsAuthorized(ws.handshakeOrigin)) {
+              pairHost.generateForSocket(ws, ws.handshakeOrigin);
+            }
+          }
+          return;
+        }
+
+        // pair_code_request — extension asks for a (re)fresh of its pair code.
+        // Only accepted from unpaired extension sockets; throttled per socket (30 s).
+        if (msg.type === "pair_code_request") {
+          if (!ws.handshakeOrigin || !ws.handshakeOrigin.startsWith("chrome-extension://")) return;
+          if (isUploadsAuthorized(ws.handshakeOrigin) || !pairHost) return;
+          pairHost.handleCodeRequest(ws, ws.handshakeOrigin);
+          return;
+        }
+
+        // uploads_pair_submit — CLI submits a 4-char code to pair an extension.
+        // Originless (CLI) callers only; extension sockets must not self-pair.
+        if (msg.type === "uploads_pair_submit") {
+          if (ws.handshakeOrigin) return; // extension socket — ignore
+          if (!pairHost) {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: "uploads_pair_result", ok: false, reason: "no_active_code" }));
+            }
+            return;
+          }
+          const result = pairHost.submitCode(msg.code);
+          if (result.ok) {
+            // Store the bare ID (without chrome-extension:// prefix).
+            const bareId = result.extensionId.slice("chrome-extension://".length).replace(/\/$/, "");
+            let trustErr = null;
+            try { addTrustedExtensionId(bareId); } catch (e) { trustErr = e; }
+            if (trustErr) {
+              // Config write failed — do NOT claim success to avoid a paired-but-not-stored split.
+              // Re-push a fresh code so the extension popup remains usable for a retry.
+              if (result.extWs && result.extWs.readyState === WebSocket.OPEN) {
+                pairHost.generateForSocket(result.extWs, result.extensionId);
+              }
+              if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({ type: "uploads_pair_result", ok: false, reason: "config_write_failed" }));
+              }
+              return;
+            }
+            if (result.extWs && result.extWs.readyState === WebSocket.OPEN) {
+              result.extWs.send(JSON.stringify({ type: "uploads_paired" }));
+            }
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: "uploads_pair_result", ok: true, extensionId: bareId }));
+            }
+          } else {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: "uploads_pair_result", ...result }));
+            }
           }
           return;
         }
 
+        // uploads_get_origins — return list of connected extension origins.
+        // Only originless (CLI/local) sockets may request this; chrome-extension://
+        // origins must not be able to enumerate other connected extensions.
+        if (msg.type === "uploads_get_origins") {
+          if (ws.handshakeOrigin) {
+            // Extension socket — refuse; only CLI callers (no origin) may enumerate.
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: "uploads_error", error: "uploads_get_origins is restricted to local CLI callers" }));
+            }
+            return;
+          }
+          const origins = [];
+          if (wss) {
+            for (const client of wss.clients) {
+              if (client.handshakeOrigin && client.handshakeOrigin.startsWith("chrome-extension://")) {
+                origins.push(client.handshakeOrigin);
+              }
+            }
+          }
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({ type: "uploads_origins", origins }));
+          }
+          return;
+        }
+
+        // Upload config/log messages — paired extension origin only.
+        // Requires the origin to be in trusted_extension_ids (via `poltertab uploads pair`).
+        // Until an ID is paired, returns uploads_not_paired.
+        if (
+          msg.type === "uploads_get_config" ||
+          msg.type === "uploads_set_config" ||
+          msg.type === "uploads_get_log"
+        ) {
+          let pairedOk, authorizedOk;
+          try {
+            pairedOk = isPaired();
+            authorizedOk = isUploadsAuthorized(ws.handshakeOrigin);
+          } catch (cfgErr) {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({
+                type: "uploads_error",
+                _replyId: msg._replyId || null,
+                error: "config read error: " + cfgErr.message,
+              }));
+            }
+            return;
+          }
+          if (!pairedOk) {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({
+                type: "uploads_not_paired",
+                _replyId: msg._replyId || null,
+                error: "Run poltertab uploads pair to link your extension",
+              }));
+            }
+            return;
+          }
+          if (!authorizedOk) {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({
+                type: "uploads_not_paired",
+                _replyId: msg._replyId || null,
+                error: "Run poltertab uploads pair to link your extension",
+              }));
+            }
+            return;
+          }
+          const os = require("os");
+          const homeDir = os.homedir();
+
+          if (msg.type === "uploads_get_config") {
+            const allowlist = getAllowlist();
+            const alwaysBlocked = buildAlwaysBlocked(homeDir);
+            const trustedExtensionIds = getTrustedExtensionIds();
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({
+                type: "uploads_config",
+                _replyId: msg._replyId || null,
+                allowlist,
+                alwaysBlocked,
+                trustedExtensionIds,
+              }));
+            }
+            return;
+          }
+
+          if (msg.type === "uploads_set_config") {
+            const { action: cfgAction, dir } = msg;
+            let result;
+            if (cfgAction === "add") {
+              const v = validateAllowlistEntry(dir, homeDir);
+              if (!v.ok) {
+                result = { ok: false, error: v.errorText };
+              } else {
+                addAllowlistEntry(dir);
+                result = { ok: true };
+              }
+            } else if (cfgAction === "remove") {
+              removeAllowlistEntry(dir);
+              result = { ok: true };
+            } else {
+              result = { ok: false, error: `Unknown action: ${cfgAction}` };
+            }
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({
+                type: "uploads_config_result",
+                _replyId: msg._replyId || null,
+                ...result,
+              }));
+            }
+            return;
+          }
+
+          if (msg.type === "uploads_get_log") {
+            const n = Math.min(typeof msg.n === "number" ? msg.n : 20, 500);
+            const entries = getRecentLog(n);
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({
+                type: "uploads_log",
+                _replyId: msg._replyId || null,
+                entries,
+              }));
+            }
+            return;
+          }
+        }
+
         // Handle captured network data
         if (msg.type === "network_data") {
           const { tabId, url, body } = msg;
@@ -1173,6 +1416,7 @@ function setupPrimaryWss(wss) {
     });
 
     ws.on("close", () => {
+      if (pairHost) pairHost.onSocketClose(ws);
       if (ws.nodeId) {
         console.error(
           `[PolterTab MCP] Secondary node disconnected: ${ws.nodeId}`,
@@ -1271,6 +1515,23 @@ function _buildEnvelope(action, params, activeNodeId) {
 // Helper to send command to the extension
 async function sendCommand(action, params) {
   if (incompatible) throw new Error(incompatibleError());
+
+  // Self-navigation guard: refuse commands targeting extension pages.
+  // Mirrors the proxy_command guard; covers the Primary's own tool calls.
+  const SENDCMD_SENSITIVE = new Set([
+    "navigate", "tab_new", "click", "fill", "snapshot", "scrape", "extract",
+  ]);
+  if (SENDCMD_SENSITIVE.has(action) && params) {
+    const urlParam = params.url || params.target || "";
+    if (typeof urlParam === "string" && urlParam) {
+      let isSelfNav = false;
+      try { isSelfNav = new URL(urlParam).protocol.toLowerCase() === "chrome-extension:"; } catch (_) {}
+      if (isSelfNav) {
+        throw new Error("[self_navigation_refused] Agent commands cannot target extension pages.");
+      }
+    }
+  }
+
   // Evicted, or a caller ahead of this one is already reconnecting: wait for
   // that one dial rather than racing it.
   if (isEvicted || reconnect) await lazyReconnect();

package/mcp-server/config.js

@@ -22,6 +22,7 @@
 // mirrored at the top of background.js with a pointer back to this comment. If
 // you change one, change both.
 
+const fs = require("fs");
 const os = require("os");
 const path = require("path");
 
@@ -37,12 +38,17 @@ const path = require("path");
 const POLTERTAB_HOME =
   process.env.POLTERTAB_HOME || path.join(os.homedir(), ".poltertab");
 
-// Port: MCP_BROWSER_WS_PORT env, then --port CLI arg, then the default.
+// Port: --port arg → MCP_BROWSER_WS_PORT env → ws_port in config.json → 7822.
 const DEFAULT_WS_PORT = 7822;
 function resolvePort(argv = process.argv, env = process.env) {
   const i = argv.indexOf("--port");
   if (i !== -1 && argv[i + 1]) return parseInt(argv[i + 1], 10);
   if (env.MCP_BROWSER_WS_PORT) return parseInt(env.MCP_BROWSER_WS_PORT, 10);
+  try {
+    const home = env.POLTERTAB_HOME || path.join(os.homedir(), ".poltertab");
+    const cfg = JSON.parse(fs.readFileSync(path.join(home, "config.json"), "utf8"));
+    if (Number.isInteger(cfg.ws_port) && cfg.ws_port > 0) return cfg.ws_port;
+  } catch (_) {}
   return DEFAULT_WS_PORT;
 }
 

package/mcp-server/index.js

@@ -36,6 +36,7 @@ const {
 const { extractAll } = require("./extract-all.js");
 const bridge = require("./bridge.js");
 const { validateUploadPaths, MAX_BYTES } = require("./upload-paths.js");
+const { logUpload } = require("./uploads-log.js");
 const OWN_VERSION = require("./../package.json").version;
 const fs = require("fs");
 const path = require("path");
@@ -222,6 +223,7 @@ const handleToolCall = async (request) => {
         checkSize: method === "drop",
       });
       if (!validation.ok) {
+        try { logUpload({ paths: filePaths, method, outcome: `denied:${validation.errorText}`, origin: null, session: opts.session || null }); } catch (_) {}
         return {
           content: [{ type: "text", text: validation.errorText }],
           isError: true,
@@ -261,7 +263,14 @@ const handleToolCall = async (request) => {
         `[poltertab] upload_file method=${method} files=${filePaths.join(", ")}\n`,
       );
 
-      const result = await bridge.sendCommand("upload_file", bridgeParams);
+      let result;
+      try {
+        result = await bridge.sendCommand("upload_file", bridgeParams);
+      } catch (uploadErr) {
+        try { logUpload({ paths: filePaths, method, outcome: "error", origin: null, session: opts.session || null }); } catch (_) {}
+        throw uploadErr;
+      }
+      try { logUpload({ paths: filePaths, method, outcome: "ok", origin: null, session: opts.session || null }); } catch (_) {}
       bridge.noteActiveTab(result && result.tabId);
       return {
         content: [{ type: "text", text: JSON.stringify(result, null, 2) }],