poltertab 1.9.0 → 1.10.0-beta.2

package/mcp-server/pair-host.js

@@ -0,0 +1,184 @@
+"use strict";
+
+// In-memory pairing state. The pair code NEVER leaves this module except
+// via the pair_code push to one socket. It is never written to config.json,
+// to uploads.log.jsonl, to the console, or returned in get_status / state_update.
+//
+// generateForSocket  — push a fresh code to an extension socket.
+// handleCodeRequest  — throttled re-push (30 s / socket).
+// submitCode         — validate a code from the CLI; returns { ok, extensionId, extWs }
+//                       or { ok: false, reason, triesLeft? / secsLeft? }.
+// onSocketClose      — void the code for a socket when it disconnects.
+
+const crypto = require("crypto");
+
+const ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"; // 31 chars; no I L O 0 1
+const CODE_LENGTH = 4;
+const CODE_TTL_MS = 5 * 60 * 1000;       // 5 minutes
+const REQUEST_THROTTLE_MS = 30 * 1000;   // 30 s per socket
+const LOCKOUT_MAX_WRONG = 5;
+const LOCKOUT_DURATION_MS = 15 * 60 * 1000; // 15 minutes
+
+function _randomCode() {
+  let s = "";
+  for (let i = 0; i < CODE_LENGTH; i++) {
+    s += ALPHABET[crypto.randomInt(ALPHABET.length)];
+  }
+  return s;
+}
+
+class PairHost {
+  // opts.codeTtlMs — injectable TTL for unit tests (defaults to 5 minutes).
+  constructor({ codeTtlMs = CODE_TTL_MS } = {}) {
+    this._codeTtlMs = codeTtlMs;
+    // code → { ws, extensionId, expiresAt, timer }
+    this._codes = new Map();
+    // ws → code
+    this._socketCodes = new Map();
+    // ws → timestamp of last pair_code_request
+    this._socketLastRequest = new Map();
+    // global wrong-guess counter
+    this._lockout = { wrongCount: 0, lockedUntil: 0 };
+    // codes that recently expired — kept for one TTL window so submitCode can
+    // tell the user "expired, try the new one" without counting it as wrong.
+    this._recentlyExpired = new Set();
+  }
+
+  _isLockedOut() {
+    return this._lockout.lockedUntil > Date.now();
+  }
+
+  _uniqueCode() {
+    let code;
+    let attempts = 0;
+    do {
+      code = _randomCode();
+    } while (this._codes.has(code) && ++attempts < 200);
+    return code;
+  }
+
+  // Push a pair_code to this extension socket.
+  // Voids any previous code for the same socket first.
+  generateForSocket(ws, extensionId) {
+    // Void old code for this socket without removing throttle tracking.
+    const old = this._socketCodes.get(ws);
+    if (old) {
+      const entry = this._codes.get(old);
+      if (entry) clearTimeout(entry.timer);
+      this._codes.delete(old);
+      this._socketCodes.delete(ws);
+      // Track as recently-expired so a late submitCode returns "expired" not "wrong".
+      this._recentlyExpired.add(old);
+      setTimeout(() => this._recentlyExpired.delete(old), this._codeTtlMs).unref();
+    }
+
+    const code = this._uniqueCode();
+    const expiresAt = Date.now() + this._codeTtlMs;
+    const timer = setTimeout(() => {
+      if (this._codes.get(code)) {
+        this._codes.delete(code);
+        this._socketCodes.delete(ws);
+        // Track as recently-expired so a late submitCode returns "expired" (not
+        // "wrong") and does not burn a lockout try.
+        this._recentlyExpired.add(code);
+        setTimeout(() => this._recentlyExpired.delete(code), this._codeTtlMs).unref();
+        // Spec: push a fresh code down the same socket so the popup never shows
+        // a dead code. If the socket is already closed, nothing to do.
+        if (ws.readyState === 1 /* OPEN */) {
+          this.generateForSocket(ws, extensionId);
+        }
+      }
+    }, this._codeTtlMs);
+
+    this._codes.set(code, { ws, extensionId, expiresAt, timer });
+    this._socketCodes.set(ws, code);
+
+    try {
+      if (ws.readyState === 1 /* OPEN */) {
+        ws.send(JSON.stringify({ type: "pair_code", code, expiresAt }));
+      }
+    } catch (_) {}
+  }
+
+  // Throttled re-request from an extension socket.
+  handleCodeRequest(ws, extensionId) {
+    const now = Date.now();
+    const last = this._socketLastRequest.get(ws) || 0;
+    if (now - last < REQUEST_THROTTLE_MS) {
+      // Re-send the existing code if one exists; otherwise ignore.
+      const existing = this._socketCodes.get(ws);
+      if (existing && this._codes.has(existing)) {
+        try {
+          if (ws.readyState === 1) {
+            ws.send(JSON.stringify({ type: "pair_code", code: existing }));
+          }
+        } catch (_) {}
+      }
+      return;
+    }
+    this._socketLastRequest.set(ws, now);
+    this.generateForSocket(ws, extensionId);
+  }
+
+  // Validate a submitted code. Called by bridge.js (from CLI) or by the temp
+  // listener (directly from the local readline prompt).
+  // Returns { ok: true, extensionId, extWs }
+  //      or { ok: false, reason: "locked_out"|"wrong"|"expired", secsLeft?, triesLeft? }
+  submitCode(rawCode) {
+    const now = Date.now();
+    if (this._isLockedOut()) {
+      const secsLeft = Math.ceil((this._lockout.lockedUntil - now) / 1000);
+      return { ok: false, reason: "locked_out", secsLeft };
+    }
+
+    const code = String(rawCode || "").toUpperCase().trim();
+    const entry = this._codes.get(code);
+
+    // Expired code: tell the user to wait for the new one; do NOT count as a
+    // wrong guess — the expiry timer already regenerated a fresh code.
+    // This handles both the sub-second race (entry still present but past
+    // expiresAt) and the post-timer case (entry deleted, code in _recentlyExpired).
+    if ((entry && entry.expiresAt < now) || this._recentlyExpired.has(code)) {
+      return { ok: false, reason: "expired" };
+    }
+
+    if (!entry) {
+      this._lockout.wrongCount += 1;
+      if (this._lockout.wrongCount >= LOCKOUT_MAX_WRONG) {
+        this._lockout = { wrongCount: 0, lockedUntil: now + LOCKOUT_DURATION_MS };
+        return {
+          ok: false,
+          reason: "locked_out",
+          secsLeft: Math.ceil(LOCKOUT_DURATION_MS / 1000),
+        };
+      }
+      return {
+        ok: false,
+        reason: "wrong",
+        triesLeft: LOCKOUT_MAX_WRONG - this._lockout.wrongCount,
+      };
+    }
+
+    // Consume — single-use.
+    clearTimeout(entry.timer);
+    this._codes.delete(code);
+    this._socketCodes.delete(entry.ws);
+    this._lockout.wrongCount = 0;
+
+    return { ok: true, extensionId: entry.extensionId, extWs: entry.ws };
+  }
+
+  // Called on every socket close in the Primary's connection handler.
+  onSocketClose(ws) {
+    const code = this._socketCodes.get(ws);
+    if (code) {
+      const entry = this._codes.get(code);
+      if (entry) clearTimeout(entry.timer);
+      this._codes.delete(code);
+      this._socketCodes.delete(ws);
+    }
+    this._socketLastRequest.delete(ws);
+  }
+}
+
+module.exports = { PairHost };

package/mcp-server/upload-paths.js

@@ -70,9 +70,9 @@ function validateUploadPaths(filePaths, config) {
     return {
       ok: false,
       errorText:
-        "File uploads are disabled. To enable them, add an upload_allowed_paths array " +
-        "to ~/.poltertab/config.json listing the directories Claude may read files from.\n\n" +
-        "Example:\n{\n  \"upload_allowed_paths\": [\"/Users/you/Documents\", \"/Users/you/Downloads\"]\n}",
+        "File uploads are disabled. The user can run `poltertab uploads allow <dir>` to permit a " +
+        "directory, or open the extension options page to manage allowed folders.\n\n" +
+        "Example:\n  poltertab uploads allow ~/Documents",
     };
   }
 
@@ -139,4 +139,74 @@ function validateUploadPaths(filePaths, config) {
   return { ok: true, resolvedPaths };
 }
 
-module.exports = { validateUploadPaths, MAX_BYTES };
+/**
+ * Validate a single path for addition to the allowlist.
+ * Accepts absolute paths and ~/relative paths. Rejects relative paths and
+ * paths inside the always-blocked set. Accepts nonexistent directories.
+ *
+ * @param {string} dir      - The path the user wants to allow.
+ * @param {string} [homeDir] - Override os.homedir() (tests only).
+ * @returns {{ ok: true } | { ok: false, errorText: string }}
+ */
+function validateAllowlistEntry(dir, homeDir = os.homedir()) {
+  if (!dir || typeof dir !== "string") {
+    return { ok: false, errorText: "Path must be a non-empty string." };
+  }
+
+  if (!path.isAbsolute(dir) && !dir.startsWith("~/")) {
+    return {
+      ok: false,
+      errorText: `"${dir}" is a relative path. Use an absolute path or ~/relative form.`,
+    };
+  }
+
+  const expanded = dir.startsWith("~/")
+    ? path.join(homeDir, dir.slice(2))
+    : dir;
+  let resolved = path.resolve(expanded);
+
+  // For existing paths: realpath so symlinks (e.g. ~/link-to-ssh) are caught
+  // by the always-blocked check below; also verify it is a directory.
+  try {
+    const real = fs.realpathSync(resolved);
+    const stat = fs.statSync(real);
+    if (!stat.isDirectory()) {
+      return {
+        ok: false,
+        errorText: `"${dir}" is a file, not a directory. Only directories can be added to the allowlist.`,
+      };
+    }
+    resolved = real;
+  } catch (_) {
+    // Path does not yet exist — accepted so future-created dirs can be pre-allowed.
+  }
+
+  const alwaysBlocked = buildAlwaysBlocked(homeDir);
+  for (const blocked of alwaysBlocked) {
+    if (resolved === blocked || resolved.startsWith(blocked + path.sep)) {
+      return {
+        ok: false,
+        errorText: `"${dir}" is inside a protected directory (${blocked}) and cannot be added.`,
+      };
+    }
+  }
+
+  // Deny home dotfiles
+  const rel = path.relative(homeDir, resolved);
+  if (!rel.startsWith("..") && rel.startsWith(".") && !rel.includes(path.sep)) {
+    return {
+      ok: false,
+      errorText: `"${dir}" is a home directory dotfile and cannot be added.`,
+    };
+  }
+
+  return { ok: true };
+}
+
+module.exports = {
+  validateUploadPaths,
+  validateAllowlistEntry,
+  buildAlwaysBlocked,
+  expandAllowlistEntry,
+  MAX_BYTES,
+};

package/mcp-server/uploads-config.js

@@ -0,0 +1,91 @@
+"use strict";
+
+// Atomic read-modify-write for the upload_allowed_paths key in config.json.
+// Preserves all other keys in config.json. Atomic write = temp file + rename.
+//
+// Used by bridge.js (WS messages) and bin/uploads.js (CLI).
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { POLTERTAB_HOME } = require("./config.js");
+
+const CONFIG_PATH = path.join(POLTERTAB_HOME, "config.json");
+
+function _readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw new Error("config.json is not valid JSON — fix it before editing the allowlist");
+  }
+}
+
+function _writeConfig(data) {
+  fs.mkdirSync(POLTERTAB_HOME, { recursive: true });
+  const tmp = CONFIG_PATH + ".tmp." + process.pid;
+  fs.writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n", "utf8");
+  fs.renameSync(tmp, CONFIG_PATH);
+}
+
+function getAllowlist() {
+  const cfg = _readConfig();
+  const v = cfg.upload_allowed_paths;
+  return Array.isArray(v) ? v : [];
+}
+
+// Adds dir to the allowlist if not already present. Returns true if added,
+// false if already present. Throws if validation fails (call
+// validateAllowlistEntry first to surface user-facing messages).
+function addAllowlistEntry(dir) {
+  const cfg = _readConfig();
+  const list = Array.isArray(cfg.upload_allowed_paths) ? cfg.upload_allowed_paths : [];
+  if (list.includes(dir)) return false;
+  _writeConfig({ ...cfg, upload_allowed_paths: [...list, dir] });
+  return true;
+}
+
+// Removes dir from the allowlist. Returns true if removed, false if absent.
+function removeAllowlistEntry(dir) {
+  const cfg = _readConfig();
+  const list = Array.isArray(cfg.upload_allowed_paths) ? cfg.upload_allowed_paths : [];
+  const next = list.filter((e) => e !== dir);
+  if (next.length === list.length) return false;
+  _writeConfig({ ...cfg, upload_allowed_paths: next });
+  return true;
+}
+
+// Adds id to trusted_extension_ids if not already present. Returns true if added.
+function addTrustedExtensionId(id) {
+  const cfg = _readConfig();
+  const list = Array.isArray(cfg.trusted_extension_ids) ? cfg.trusted_extension_ids : [];
+  if (list.includes(id)) return false;
+  _writeConfig({ ...cfg, trusted_extension_ids: [...list, id] });
+  return true;
+}
+
+function getTrustedExtensionIds() {
+  const cfg = _readConfig();
+  const v = cfg.trusted_extension_ids;
+  return Array.isArray(v) ? v : [];
+}
+
+// Removes id from trusted_extension_ids. Returns true if removed, false if absent.
+function removeTrustedExtensionId(id) {
+  const cfg = _readConfig();
+  const list = Array.isArray(cfg.trusted_extension_ids) ? cfg.trusted_extension_ids : [];
+  const next = list.filter((e) => e !== id);
+  if (next.length === list.length) return false;
+  _writeConfig({ ...cfg, trusted_extension_ids: next });
+  return true;
+}
+
+module.exports = {
+  getAllowlist,
+  addAllowlistEntry,
+  removeAllowlistEntry,
+  addTrustedExtensionId,
+  getTrustedExtensionIds,
+  removeTrustedExtensionId,
+  CONFIG_PATH,
+};

package/mcp-server/uploads-log.js

@@ -0,0 +1,59 @@
+"use strict";
+
+// Append + rotate upload activity log at ~/.poltertab/uploads.log.jsonl.
+// Each entry: { ts, paths, method, outcome, origin, session }.
+// Rotation: drop oldest lines until the file is ≤ LOG_MAX_BYTES.
+
+const fs = require("fs");
+const path = require("path");
+const { POLTERTAB_HOME } = require("./config.js");
+
+const LOG_PATH = path.join(POLTERTAB_HOME, "uploads.log.jsonl");
+const LOG_MAX_BYTES = 1 * 1024 * 1024; // 1 MB
+
+function logUpload({ paths, method, outcome, origin, session }) {
+  const line =
+    JSON.stringify({
+      ts: new Date().toISOString(),
+      paths,
+      method,
+      outcome,
+      origin: origin || null,
+      session: session || null,
+    }) + "\n";
+
+  fs.mkdirSync(POLTERTAB_HOME, { recursive: true });
+  fs.appendFileSync(LOG_PATH, line, "utf8");
+
+  // Rotate if file exceeds limit
+  try {
+    const stat = fs.statSync(LOG_PATH);
+    if (stat.size > LOG_MAX_BYTES) {
+      let content = fs.readFileSync(LOG_PATH, "utf8");
+      const lines = content.split("\n").filter(Boolean);
+      while (lines.length > 1 && Buffer.byteLength(lines.join("\n") + "\n") > LOG_MAX_BYTES) {
+        lines.shift();
+      }
+      fs.writeFileSync(LOG_PATH, lines.join("\n") + "\n", "utf8");
+    }
+  } catch (_) {
+    // Rotation failure is non-fatal
+  }
+}
+
+function getRecentLog(n = 20) {
+  try {
+    const content = fs.readFileSync(LOG_PATH, "utf8");
+    const lines = content.split("\n").filter(Boolean);
+    return lines
+      .slice(-n)
+      .map((l) => {
+        try { return JSON.parse(l); } catch (_) { return null; }
+      })
+      .filter(Boolean);
+  } catch (_) {
+    return [];
+  }
+}
+
+module.exports = { logUpload, getRecentLog, LOG_PATH, LOG_MAX_BYTES };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poltertab",
-  "version": "1.9.0",
+  "version": "1.10.0-beta.2",
   "description": "Let any AI assistant drive and scrape your existing Chrome profile — no headless browser, no complex setup.",
   "bin": {
     "poltertab": "./bin/poltertab.js"