agentlas 1.0.65 → 1.0.66

package/engine/automation/store.cjs

@@ -14,7 +14,7 @@
  */
 const crypto = require("node:crypto");
 const os = require("node:os");
-const { columnExists, tableExists } = require("../core/db.cjs");
+const { columnExists, tableExists, runWriteTransaction } = require("../core/db.cjs");
 const { nextAutomationRun } = require("./schedule.cjs");
 
 const LEASE_TTL_MS = 15 * 60 * 1000; // 앱 store/automations.ts LEASE_TTL_MS와 동일
@@ -31,7 +31,49 @@ function listAutomations(db) {
 
 function getAutomationByPrefix(db, idPrefix) {
   if (!tableExists(db, "automations")) return null;
-  return db.prepare("SELECT * FROM automations WHERE id LIKE ?").get(String(idPrefix) + "%") || null;
+  const prefix = String(idPrefix || "").trim();
+  if (!prefix) return null;
+  const exact = db.prepare("SELECT * FROM automations WHERE id = ?").get(prefix);
+  if (exact) return exact;
+  // LIKE를 쓰면 사용자가 입력한 %/_가 와일드카드가 되어 전혀 다른 행을 고른다.
+  // 두 행 이상이면 임의의 첫 행을 mutation 대상으로 삼지 않고 전체 ID를 요구한다.
+  const matches = db.prepare(
+    "SELECT * FROM automations WHERE substr(id, 1, length(?)) = ? ORDER BY id LIMIT 2",
+  ).all(prefix, prefix);
+  if (matches.length > 1) throw new Error(`automation id prefix is ambiguous: ${prefix}`);
+  return matches[0] || null;
+}
+
+function resultChanges(result) {
+  return Number(result && (result.changes ?? result.rowsAffected) || 0);
+}
+
+function validLease(lease) {
+  return Boolean(
+    lease && typeof lease.owner === "string" && lease.owner &&
+    typeof lease.claimedAt === "string" && lease.claimedAt,
+  );
+}
+
+/**
+ * Build the fencing predicate for a post-claim write. When a legacy caller has
+ * no lease token, only an actually-unclaimed row may be updated; an active
+ * successor lease is never touched. The daemon always supplies the exact
+ * owner+claimed_at pair returned by claimAutomationLease().
+ */
+function leaseFence(db, id, lease = null, row = null) {
+  const parts = ["id = ?"];
+  const params = [id];
+  if (!leaseSupported(db)) return { sql: parts.join(" AND "), params };
+  if (validLease(lease)) {
+    parts.push("lease_owner = ?", "claimed_at = ?");
+    params.push(lease.owner, lease.claimedAt);
+  } else if (row && row.lease_owner == null && row.claimed_at == null) {
+    parts.push("lease_owner IS NULL", "claimed_at IS NULL");
+  } else {
+    parts.push("0");
+  }
+  return { sql: parts.join(" AND "), params };
 }
 
 /**
@@ -75,17 +117,21 @@ function addAutomation(db, spec, next) {
 
 /** on: next_run_at 재계산 후 활성화. off: 비활성화(스케줄 보존). */
 function setEnabled(db, row, enabled) {
+  return setEnabledChecked(db, row, enabled).next;
+}
+
+function setEnabledChecked(db, row, enabled) {
   if (enabled) {
     const next = nextAutomationRun(row) || null;
-    db.prepare("UPDATE automations SET enabled=1, next_run_at=? WHERE id=?").run(next ? next.toISOString() : null, row.id);
-    return next;
+    const result = db.prepare("UPDATE automations SET enabled=1, next_run_at=? WHERE id=?").run(next ? next.toISOString() : null, row.id);
+    return { changed: resultChanges(result) > 0, next };
   }
-  db.prepare("UPDATE automations SET enabled=0 WHERE id=?").run(row.id);
-  return null;
+  const result = db.prepare("UPDATE automations SET enabled=0 WHERE id=?").run(row.id);
+  return { changed: resultChanges(result) > 0, next: null };
 }
 
 function removeAutomation(db, id) {
-  db.prepare("DELETE FROM automations WHERE id=?").run(id);
+  return resultChanges(db.prepare("DELETE FROM automations WHERE id=?").run(id)) > 0;
 }
 
 /**
@@ -94,15 +140,21 @@ function removeAutomation(db, id) {
  * @returns {boolean} true = 이 프로세스가 배타 실행권을 가짐
  */
 function claimAutomation(db, id, now = new Date(), owner = LEASE_OWNER) {
+  return Boolean(claimAutomationLease(db, id, now, owner));
+}
+
+/** Claim and return the exact owner+claimed_at fence used by this run. */
+function claimAutomationLease(db, id, now = new Date(), owner = LEASE_OWNER) {
   // 리스 열이 없으면 배타성을 증명할 수 없다 — 중복 실행 위험을 감수하지 않고 거부.
-  if (!leaseSupported(db)) return false;
+  if (!leaseSupported(db)) return null;
   const cutoff = new Date(now.getTime() - LEASE_TTL_MS).toISOString();
+  const claimedAt = now.toISOString();
   const result = db
     .prepare(
       "UPDATE automations SET claimed_at = ?, lease_owner = ? WHERE id = ? AND enabled = 1 AND (claimed_at IS NULL OR claimed_at < ?)",
     )
-    .run(now.toISOString(), owner, id, cutoff);
-  return (result.changes ?? result.rowsAffected ?? 0) > 0;
+    .run(claimedAt, owner, id, cutoff);
+  return resultChanges(result) > 0 ? { owner, claimedAt } : null;
 }
 
 /**
@@ -115,6 +167,7 @@ function claimAutomation(db, id, now = new Date(), owner = LEASE_OWNER) {
  * 리스를 되빼앗지는 않는다.
  */
 function renewAutomationLease(db, id, now = new Date(), owner = LEASE_OWNER) {
+  if (arguments.length >= 5) return Boolean(renewAutomationLeaseToken(db, id, now, { owner, claimedAt: arguments[4] }));
   if (!leaseSupported(db)) return false;
   // false means definitive ownership loss. SQLite busy/I/O errors must throw
   // so the caller can retry instead of killing a valid run as if a peer had
@@ -122,15 +175,30 @@ function renewAutomationLease(db, id, now = new Date(), owner = LEASE_OWNER) {
   const result = db
     .prepare("UPDATE automations SET claimed_at = ? WHERE id = ? AND lease_owner = ? AND claimed_at IS NOT NULL")
     .run(now.toISOString(), id, owner);
-  return (result.changes ?? result.rowsAffected ?? 0) > 0;
+  return resultChanges(result) > 0;
+}
+
+/** Renew an exact fence and return its new claimed_at value. */
+function renewAutomationLeaseToken(db, id, now = new Date(), lease) {
+  if (!leaseSupported(db) || !validLease(lease)) return null;
+  const claimedAt = now.toISOString();
+  const result = db
+    .prepare("UPDATE automations SET claimed_at = ? WHERE id = ? AND lease_owner = ? AND claimed_at = ?")
+    .run(claimedAt, id, lease.owner, lease.claimedAt);
+  return resultChanges(result) > 0 ? { owner: lease.owner, claimedAt } : null;
 }
 
-function releaseAutomation(db, id, owner = LEASE_OWNER) {
+function releaseAutomation(db, id, owner = LEASE_OWNER, claimedAt = null) {
   try {
+    if (owner && typeof owner === "object") {
+      claimedAt = owner.claimedAt || null;
+      owner = owner.owner || LEASE_OWNER;
+    }
+    const token = typeof claimedAt === "string" && claimedAt ? " AND claimed_at = ?" : "";
     const result = db
-      .prepare("UPDATE automations SET claimed_at = NULL, lease_owner = NULL WHERE id = ? AND lease_owner = ?")
-      .run(id, owner);
-    return (result.changes ?? result.rowsAffected ?? 0) > 0;
+      .prepare(`UPDATE automations SET claimed_at = NULL, lease_owner = NULL WHERE id = ? AND lease_owner = ?${token}`)
+      .run(...(token ? [id, owner, claimedAt] : [id, owner]));
+    return resultChanges(result) > 0;
   } catch { return false; }
 }
 
@@ -138,22 +206,33 @@ function releaseAutomation(db, id, owner = LEASE_OWNER) {
  * 실행 기록 — run_history(v1/Desktop 스케줄러 패리티) + automation_runs(있으면) 양쪽.
  * best-effort: 기록 실패가 자동화 실행 자체를 죽이면 안 된다.
  */
-function recordRun(db, automationId, status, error, scheduledFor) {
+function recordRun(db, automationId, status, error, scheduledFor, lease) {
+  if (!leaseSupported(db) || !validLease(lease)) return { ok: false, leaseLost: true, recorded: false };
   const nowIso = new Date().toISOString();
   try {
-    if (tableExists(db, "run_history")) {
-      db.prepare(
-        "INSERT INTO run_history (id, automation_id, scheduled_for, ran_at, status, skipped_count, error) VALUES (?,?,?,?,?,0,?)",
-      ).run(crypto.randomUUID(), automationId, scheduledFor || null, nowIso, status, error || null);
-    }
-  } catch { /* best-effort */ }
-  try {
-    if (tableExists(db, "automation_runs")) {
-      db.prepare(
-        "INSERT INTO automation_runs (id, automation_id, started_at, status, node_states_json) VALUES (?,?,?,?,NULL)",
-      ).run(crypto.randomUUID(), automationId, nowIso, status);
-    }
-  } catch { /* best-effort */ }
+    return runWriteTransaction(db, () => {
+      const fence = leaseFence(db, automationId, lease);
+      let recorded = false;
+      if (tableExists(db, "run_history")) {
+        const result = db.prepare(
+          `INSERT INTO run_history (id, automation_id, scheduled_for, ran_at, status, skipped_count, error)
+             SELECT ?,?,?,?,?,0,? FROM automations WHERE ${fence.sql}`,
+        ).run(crypto.randomUUID(), automationId, scheduledFor || null, nowIso, status, error || null, ...fence.params);
+        recorded = recorded || resultChanges(result) > 0;
+      }
+      if (tableExists(db, "automation_runs")) {
+        const result = db.prepare(
+          `INSERT INTO automation_runs (id, automation_id, started_at, status, node_states_json)
+             SELECT ?,?,?,?,NULL FROM automations WHERE ${fence.sql}`,
+        ).run(crypto.randomUUID(), automationId, nowIso, status, ...fence.params);
+        recorded = recorded || resultChanges(result) > 0;
+      }
+      const stillOwned = db.prepare(`SELECT 1 FROM automations WHERE ${fence.sql}`).get(...fence.params);
+      return { ok: Boolean(stillOwned), leaseLost: !stillOwned, recorded };
+    });
+  } catch (error) {
+    return { ok: false, leaseLost: false, recorded: false, error: String((error && error.message) || error) };
+  }
 }
 
 function listRuns(db, limit = 15) {
@@ -174,8 +253,9 @@ function listRuns(db, limit = 15) {
  * ("Disabled: … morning" 을 보고 exit 0 인데도) 다음 예정 시각에 또 발화한다.
  * 그래서 enabled 는 "켜기"로는 절대 쓰지 않고, 종료 조건일 때만 0 으로 내린다.
  */
-function disableExhausted(db, id) {
-  db.prepare("UPDATE automations SET enabled = 0 WHERE id = ?").run(id);
+function disableExhausted(db, id, lease = null, row = null) {
+  const fence = leaseFence(db, id, lease, row);
+  return resultChanges(db.prepare(`UPDATE automations SET enabled = 0 WHERE ${fence.sql}`).run(...fence.params)) > 0;
 }
 
 /**
@@ -188,40 +268,61 @@ function disableExhausted(db, id) {
  * (같은 이유로 성공/실패 두 분기 모두 같은 규칙을 따라야 한다: 한쪽만 고치면
  *  실패로 끝난 실행이 여전히 끈 자동화를 부활시킨다.)
  */
-function advanceAfterRun(db, row, { ok, advanceSchedule, ranAt = new Date() } = {}) {
+function advanceAfterRun(db, row, { ok, advanceSchedule, ranAt = new Date(), lease = null } = {}) {
   const hasRunCount = columnExists(db, "automations", "run_count");
   const shouldAdvance = !!advanceSchedule && (row.trigger_type || "schedule") === "schedule";
   const advance = shouldAdvance ? nextAutomationRun(row, ranAt) : null;
-  if (ok) {
-    if (shouldAdvance) {
-      if (hasRunCount) {
-        db.prepare(
-          "UPDATE automations SET last_run_at = ?, run_count = run_count + 1, next_run_at = ? WHERE id = ?",
-        ).run(ranAt.toISOString(), advance ? advance.toISOString() : null, row.id);
+  try {
+    return runWriteTransaction(db, () => {
+      const fence = leaseFence(db, row.id, lease, row);
+      let result;
+      if (ok) {
+        if (shouldAdvance) {
+          const sql = hasRunCount
+            ? "UPDATE automations SET last_run_at = ?, run_count = run_count + 1, next_run_at = ?"
+            : "UPDATE automations SET last_run_at = ?, next_run_at = ?";
+          result = db.prepare(`${sql} WHERE ${fence.sql}`).run(
+            ranAt.toISOString(), advance ? advance.toISOString() : null, ...fence.params,
+          );
+        } else if (hasRunCount) {
+          result = db.prepare(`UPDATE automations SET last_run_at = ?, run_count = run_count + 1 WHERE ${fence.sql}`)
+            .run(ranAt.toISOString(), ...fence.params);
+        } else {
+          result = db.prepare(`UPDATE automations SET last_run_at = ? WHERE ${fence.sql}`).run(ranAt.toISOString(), ...fence.params);
+        }
+      } else if (shouldAdvance) {
+        result = db.prepare(`UPDATE automations SET last_run_at = ?, next_run_at = ? WHERE ${fence.sql}`)
+          .run(ranAt.toISOString(), advance ? advance.toISOString() : null, ...fence.params);
       } else {
-        db.prepare("UPDATE automations SET last_run_at = ?, next_run_at = ? WHERE id = ?")
-          .run(ranAt.toISOString(), advance ? advance.toISOString() : null, row.id);
+        result = db.prepare(`UPDATE automations SET last_run_at = ? WHERE ${fence.sql}`).run(ranAt.toISOString(), ...fence.params);
       }
-      if (!advance) disableExhausted(db, row.id);
-    } else if (hasRunCount) {
-      db.prepare("UPDATE automations SET last_run_at = ?, run_count = run_count + 1 WHERE id = ?")
-        .run(ranAt.toISOString(), row.id);
-    } else {
-      db.prepare("UPDATE automations SET last_run_at = ? WHERE id = ?").run(ranAt.toISOString(), row.id);
-    }
-    // max_runs 도달 시 비활성화 (앱과 동일한 종료 조건).
-    if (row.max_runs && (row.run_count || 0) + 1 >= row.max_runs) {
-      disableExhausted(db, row.id);
-      return { advance, maxRunsReached: true };
-    }
-  } else if (shouldAdvance) {
-    db.prepare("UPDATE automations SET last_run_at = ?, next_run_at = ? WHERE id = ?")
-      .run(ranAt.toISOString(), advance ? advance.toISOString() : null, row.id);
-    if (!advance) disableExhausted(db, row.id);
-  } else {
-    db.prepare("UPDATE automations SET last_run_at = ? WHERE id = ?").run(ranAt.toISOString(), row.id);
+      if (resultChanges(result) === 0) return { advance, maxRunsReached: false, updated: false, leaseLost: true };
+
+      let maxRunsReached = false;
+      if (shouldAdvance && !advance) {
+        if (!disableExhausted(db, row.id, lease, row)) {
+          return { advance, maxRunsReached: false, updated: false, leaseLost: true };
+        }
+        maxRunsReached = true;
+      }
+      // max_runs 도달 시 비활성화 (앱과 동일한 종료 조건).
+      if (ok && row.max_runs && (row.run_count || 0) + 1 >= row.max_runs) {
+        if (!disableExhausted(db, row.id, lease, row)) {
+          return { advance, maxRunsReached: false, updated: false, leaseLost: true };
+        }
+        maxRunsReached = true;
+      }
+      return { advance, maxRunsReached, updated: true, leaseLost: false };
+    });
+  } catch (error) {
+    return {
+      advance,
+      maxRunsReached: false,
+      updated: false,
+      leaseLost: false,
+      error: String((error && error.message) || error),
+    };
   }
-  return { advance, maxRunsReached: false };
 }
 
 /**
@@ -279,9 +380,12 @@ module.exports = {
   getAutomationByPrefix,
   addAutomation,
   setEnabled,
+  setEnabledChecked,
   removeAutomation,
   claimAutomation,
+  claimAutomationLease,
   renewAutomationLease,
+  renewAutomationLeaseToken,
   releaseAutomation,
   recordRun,
   listRuns,

package/engine/browser/cdp.cjs

@@ -17,24 +17,83 @@
  * 안전: Agentlas 전용 프로필 Chrome 에만 붙는다(개인 크롬 아님). 되돌릴 수 없는
  * 행동은 호출자가 판단한다 — 이 모듈은 조종 primitive 만 제공한다.
  */
+const crypto = require("node:crypto");
+const fs = require("node:fs");
 const http = require("node:http");
+const path = require("node:path");
 
 const DEFAULT_PORT = Number(process.env.AGENTLAS_CDP_PORT || 9222);
 const DEFAULT_WS_OPEN_TIMEOUT_MS = 5_000;
+const CDP_HTTP_TIMEOUT_MS = 3_000;
+const CDP_HTTP_MAX_BYTES = 8 * 1024 * 1024;
+const CDP_PDF_MAX_BYTES = 64 * 1024 * 1024;
 const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
 
-function httpJson(port, path, { timeout = 3000, method = "GET" } = {}) {
+function httpJson(port, requestPath, { timeout = CDP_HTTP_TIMEOUT_MS, method = "GET" } = {}) {
+  const limit = Number.isFinite(Number(timeout)) && Number(timeout) > 0
+    ? Number(timeout)
+    : CDP_HTTP_TIMEOUT_MS;
   return new Promise((resolve, reject) => {
-    const req = http.request({ host: "127.0.0.1", port, path, timeout, method }, (res) => {
-      let body = "";
-      res.on("data", (d) => { body += d; });
-      res.on("end", () => {
-        try { resolve(JSON.parse(body)); } catch (e) { reject(e); }
+    let req = null;
+    let response = null;
+    let timer = null;
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (error) {
+        try { response?.destroy(); } catch { /* already closed */ }
+        try { req?.destroy(); } catch { /* already closed */ }
+        reject(error);
+      } else {
+        resolve(value);
+      }
+    };
+    const timeoutError = () => {
+      const error = new Error(`CDP ${requestPath} timed out`);
+      error.code = "CDP_HTTP_TIMEOUT";
+      return error;
+    };
+    try {
+      req = http.request({ host: "127.0.0.1", port, path: requestPath, timeout: limit, method }, (res) => {
+        response = res;
+        const chunks = [];
+        let bodyBytes = 0;
+        res.on("data", (chunk) => {
+          if (settled) return;
+          const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          bodyBytes += bytes.length;
+          if (bodyBytes > CDP_HTTP_MAX_BYTES) {
+            const error = new Error(`CDP ${requestPath} response exceeded ${CDP_HTTP_MAX_BYTES} bytes`);
+            error.code = "CDP_HTTP_BODY_LIMIT";
+            finish(error);
+            return;
+          }
+          chunks.push(bytes);
+        });
+        res.on("aborted", () => finish(new Error(`CDP ${requestPath} response aborted`)));
+        res.on("error", (error) => finish(error));
+        res.on("end", () => {
+          if (settled) return;
+          try {
+            finish(null, JSON.parse(Buffer.concat(chunks, bodyBytes).toString("utf8")));
+          } catch (error) {
+            finish(error);
+          }
+        });
       });
-    });
-    req.on("error", reject);
-    req.on("timeout", () => { req.destroy(); reject(new Error(`CDP ${path} timed out`)); });
-    req.end();
+      req.on("error", (error) => finish(error));
+      // Keep the inactivity timeout as a fast-path, but also enforce the
+      // absolute deadline below so a peer cannot keep this request alive by
+      // dripping one byte before every inactivity interval.
+      req.on("timeout", () => finish(timeoutError()));
+      timer = setTimeout(() => finish(timeoutError()), limit);
+      timer.unref?.();
+      req.end();
+    } catch (error) {
+      finish(error);
+    }
   });
 }
 
@@ -96,21 +155,115 @@ async function pickPageTarget(port = DEFAULT_PORT, options = {}) {
 
 function closePageTarget(port, targetId) {
   return new Promise((resolve) => {
+    let settled = false;
+    let timer = null;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      resolve();
+    };
     const req = http.request({
       host: "127.0.0.1",
       port,
       path: `/json/close/${encodeURIComponent(String(targetId))}`,
-      timeout: 3_000,
+      timeout: CDP_HTTP_TIMEOUT_MS,
     }, (res) => {
       res.resume();
-      res.once("end", resolve);
+      res.once("end", finish);
+      res.once("aborted", finish);
+      res.once("error", finish);
     });
-    req.once("error", resolve);
-    req.once("timeout", () => { req.destroy(); resolve(); });
+    req.once("error", finish);
+    req.once("timeout", () => { req.destroy(); finish(); });
+    timer = setTimeout(() => { req.destroy(); finish(); }, CDP_HTTP_TIMEOUT_MS);
+    timer.unref?.();
     req.end();
   });
 }
 
+function sameFileIdentity(left, right) {
+  return left && right && String(left.dev) === String(right.dev) && String(left.ino) === String(right.ino);
+}
+
+function writeAtomicRegularFile(outPath, data) {
+  const target = path.resolve(String(outPath));
+  let original = null;
+  try {
+    original = fs.lstatSync(target);
+    if (!original.isFile() || original.nlink !== 1) {
+      const error = new Error(`CDP output path must be a regular file with one link: ${target}`);
+      error.code = "CDP_UNSAFE_OUTPUT_PATH";
+      throw error;
+    }
+  } catch (error) {
+    if (error && error.code !== "ENOENT") throw error;
+  }
+
+  const dir = path.dirname(target);
+  const base = path.basename(target);
+  const flags = fs.constants.O_WRONLY
+    | fs.constants.O_CREAT
+    | fs.constants.O_EXCL
+    | (fs.constants.O_NOFOLLOW || 0);
+  let temp = null;
+  let fd = null;
+  try {
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      temp = path.join(dir, `.${base}.${process.pid}.${crypto.randomUUID()}.tmp`);
+      try {
+        fd = fs.openSync(temp, flags, 0o600);
+        break;
+      } catch (error) {
+        temp = null;
+        if (!error || error.code !== "EEXIST" || attempt === 2) throw error;
+      }
+    }
+    if (fd == null || !temp) throw new Error("could not create a temporary CDP output file");
+    let offset = 0;
+    while (offset < data.length) {
+      const written = fs.writeSync(fd, data, offset, data.length - offset);
+      if (!written) throw new Error("could not write the CDP output file");
+      offset += written;
+    }
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    fd = null;
+
+    // Refuse a path that changed identity while the temporary file was being
+    // written. The final rename itself never follows a symlink or hardlink.
+    let current = null;
+    try { current = fs.lstatSync(target); } catch (error) {
+      if (!error || error.code !== "ENOENT") throw error;
+    }
+    if (original) {
+      if (!current || !current.isFile() || current.nlink !== 1 || !sameFileIdentity(original, current)) {
+        const error = new Error(`CDP output path changed while writing: ${target}`);
+        error.code = "CDP_OUTPUT_IDENTITY_CHANGED";
+        throw error;
+      }
+    } else if (current) {
+      // The caller observed an absent path. A file appearing before commit is
+      // a competing writer, even when it is otherwise a safe regular file.
+      // Never overwrite a file whose identity this operation did not capture.
+      const error = new Error(`CDP output path appeared while writing: ${target}`);
+      error.code = current.isFile() && current.nlink === 1
+        ? "CDP_OUTPUT_IDENTITY_CHANGED"
+        : "CDP_UNSAFE_OUTPUT_PATH";
+      throw error;
+    }
+    fs.renameSync(temp, target);
+    temp = null;
+  } finally {
+    if (fd != null) {
+      try { fs.closeSync(fd); } catch { /* already closed */ }
+    }
+    if (temp) {
+      try { fs.unlinkSync(temp); } catch { /* best-effort cleanup */ }
+    }
+  }
+}
+
 function waitForWebSocketOpen(ws, timeoutMs) {
   return new Promise((resolve, reject) => {
     let settled = false;
@@ -280,9 +433,19 @@ async function attachPage({ port = DEFAULT_PORT, wsUrl, selection = "new", targe
   async function printPdf(outPath, { landscape = false, printBackground = true, scale = 1 } = {}) {
     const res = await send("Page.printToPDF", { landscape, printBackground, scale, transferMode: "ReturnAsBase64" }, { timeout: 60000 });
     const b64 = res && res.data;
-    if (!b64) throw new Error("Page.printToPDF returned no data");
+    if (typeof b64 !== "string" || !b64) throw new Error("Page.printToPDF returned no data");
+    if (b64.length > Math.ceil(CDP_PDF_MAX_BYTES / 3) * 4) {
+      const error = new Error(`Page.printToPDF response exceeded ${CDP_PDF_MAX_BYTES} bytes`);
+      error.code = "CDP_PDF_BODY_LIMIT";
+      throw error;
+    }
     const buf = Buffer.from(b64, "base64");
-    require("node:fs").writeFileSync(outPath, buf);
+    if (buf.length > CDP_PDF_MAX_BYTES) {
+      const error = new Error(`Page.printToPDF response exceeded ${CDP_PDF_MAX_BYTES} bytes`);
+      error.code = "CDP_PDF_BODY_LIMIT";
+      throw error;
+    }
+    writeAtomicRegularFile(outPath, buf);
     return { path: outPath, bytes: buf.length };
   }
 
@@ -301,4 +464,14 @@ async function attachPage({ port = DEFAULT_PORT, wsUrl, selection = "new", targe
   };
 }
 
-module.exports = { cdpReady, pickPageTarget, attachPage, DEFAULT_PORT, DEFAULT_WS_OPEN_TIMEOUT_MS };
+module.exports = {
+  cdpReady,
+  pickPageTarget,
+  attachPage,
+  DEFAULT_PORT,
+  DEFAULT_WS_OPEN_TIMEOUT_MS,
+  CDP_HTTP_TIMEOUT_MS,
+  CDP_HTTP_MAX_BYTES,
+  CDP_PDF_MAX_BYTES,
+  writeAtomicRegularFile,
+};

package/engine/browser/vault.cjs

@@ -22,6 +22,7 @@ function normalizeSite(input) {
   if (!raw) return "";
   let u;
   try { u = new URL(/^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `https://${raw}`); } catch { return ""; }
+  if (u.protocol !== "http:" && u.protocol !== "https:") return "";
   if (u.username || u.password) return ""; // 자격증명은 사이트 키에 절대 들이지 않는다
   const host = u.host.toLowerCase().replace(/^www\./, "");
   return host && !/\s/.test(host) ? host : "";