cetrix-connect 0.3.0

package/dist/agent.mjs

@@ -0,0 +1,2591 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/agent/files.mjs
+var files_exports = {};
+__export(files_exports, {
+  executeTool: () => executeTool,
+  runCommand: () => runCommand,
+  safePath: () => safePath
+});
+import fs2 from "node:fs/promises";
+import path2 from "node:path";
+import { constants } from "node:fs";
+import { spawn as spawn2 } from "node:child_process";
+function within(root, target) {
+  const rel = path2.relative(root, target);
+  return rel === "" || !rel.startsWith(".." + path2.sep) && rel !== ".." && !path2.isAbsolute(rel);
+}
+async function safePath(config, requested2, { write = false } = {}) {
+  if (typeof requested2 !== "string" || requested2.length > 1024 || requested2.includes("\0") || /^[\\/]/.test(requested2) || requested2.includes(":")) throw new Error("Only relative paths are allowed");
+  const segments = requested2.replaceAll("\\", "/").split("/");
+  if (segments.includes("..") || segments.some(protectedName)) throw new Error("Path is outside the allowed file policy");
+  const root = await fs2.realpath(config.root), candidate = path2.resolve(root, requested2);
+  if (!within(root, candidate)) throw new Error("Path escapes approved root");
+  let resolved;
+  try {
+    resolved = await fs2.realpath(candidate);
+  } catch (error) {
+    if (!write || error.code !== "ENOENT") throw error;
+    resolved = path2.join(await fs2.realpath(path2.dirname(candidate)), path2.basename(candidate));
+  }
+  if (!within(root, resolved)) throw new Error("Symlink escapes approved root");
+  if (config.allowedDirectories !== void 0) {
+    const allowed = await Promise.all(config.allowedDirectories.map((item) => fs2.realpath(item)));
+    if (!allowed.some((item) => within(root, item) && within(item, resolved))) throw new Error("Path is outside configured allowed directories");
+  }
+  if (path2.relative(root, resolved).split(path2.sep).some(protectedName)) throw new Error("Path is outside the allowed file policy");
+  for (const item of config.deniedPaths || []) {
+    const denied = await fs2.realpath(item).catch(() => path2.resolve(item));
+    if (within(denied, resolved)) throw new Error("Agent/server credentials are protected");
+  }
+  return resolved;
+}
+function runCommand(config, args) {
+  if (!config.allowShell) throw new Error("Shell execution is disabled on this PC");
+  if (typeof args.command !== "string" || args.command.length < 1 || args.command.length > 4096) throw new Error("Invalid command");
+  const timeout = Math.min(25, Math.max(1, Number(args.timeoutSeconds) || 15)) * 1e3;
+  return new Promise((resolve, reject) => {
+    const child = spawn2(args.command, { shell: config.defaultShell || (process.platform === "win32" ? "powershell.exe" : true), cwd: config.root, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "", stderr = "", size = 0, killed = false, done = false;
+    const stop = () => {
+      killed = true;
+      if (process.platform === "win32" && child.pid) {
+        const killer = spawn2("taskkill", ["/pid", String(child.pid), "/t", "/f"], { windowsHide: true, stdio: "ignore" });
+        killer.on("error", () => child.kill());
+      } else child.kill("SIGKILL");
+    };
+    const timer = setTimeout(stop, timeout);
+    const collect = (which) => (data) => {
+      size += data.length;
+      if (size > 65536) {
+        stop();
+        return;
+      }
+      if (which === "out") stdout += data.toString();
+      else stderr += data.toString();
+    };
+    child.stdout.on("data", collect("out"));
+    child.stderr.on("data", collect("err"));
+    child.on("error", (error) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code, signal) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      resolve({ stdout, stderr, exitCode: code, signal, terminated: killed });
+    });
+  });
+}
+async function executeTool(config, tool2, args) {
+  if (tool2 === "run_command") return runCommand(config, args);
+  if (tool2 === "list_directory") {
+    const target = await safePath(config, args.path || ".");
+    const entries = await fs2.readdir(target, { withFileTypes: true });
+    return { entries: entries.filter((e) => !protectedName(e.name)).slice(0, 200).map((e) => ({ name: e.name, type: e.isSymbolicLink() ? "symlink" : e.isDirectory() ? "directory" : "file" })), truncated: entries.length > 200 };
+  }
+  if (tool2 === "read_file") {
+    const target = await safePath(config, args.path), handle = await fs2.open(target, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+    try {
+      const stat = await handle.stat();
+      if (!stat.isFile() || stat.size > 65536) throw new Error("Only files up to 64 KiB are supported");
+      const buffer = Buffer.alloc(65537);
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+      if (bytesRead > 65536) throw new Error("Maximum file size is 64 KiB");
+      const data = buffer.subarray(0, bytesRead);
+      if (data.includes(0)) throw new Error("Binary file not supported");
+      return { content: data.toString("utf8"), bytes: data.length };
+    } finally {
+      await handle.close();
+    }
+  }
+  if (tool2 === "write_file") {
+    if (!config.allowWrite) throw new Error("File writes are disabled on this PC");
+    if (typeof args.content !== "string" || Buffer.byteLength(args.content) > 65536) throw new Error("Maximum file content is 64 KiB");
+    const target = await safePath(config, args.path, { write: true });
+    const flags = constants.O_WRONLY | constants.O_CREAT | (args.overwrite ? constants.O_TRUNC : constants.O_EXCL) | (constants.O_NOFOLLOW || 0);
+    const handle = await fs2.open(target, flags, 384);
+    try {
+      await handle.writeFile(args.content, "utf8");
+    } finally {
+      await handle.close();
+    }
+    return { written: true, bytes: Buffer.byteLength(args.content) };
+  }
+  throw new Error("Tool is not supported by this agent");
+}
+var protectedName;
+var init_files = __esm({
+  "src/agent/files.mjs"() {
+    protectedName = (name) => /^\.env(?:\..*)?$|^\.git$|^\.ssh$|^\.aws$|^\.cetrix/i.test(name);
+  }
+});
+
+// src/agent/entry.mjs
+import fs7 from "node:fs/promises";
+import path9 from "node:path";
+import os2 from "node:os";
+import { generateKeyPairSync, randomUUID as randomUUID5 } from "node:crypto";
+import { parseArgs } from "node:util";
+import { spawn as spawn4 } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+import { createInterface } from "node:readline/promises";
+
+// src/agent/identity.mjs
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { execFile } from "node:child_process";
+var run = promisify(execFile);
+function dpapi(mode, input) {
+  const operation = mode === "protect" ? "Protect" : "Unprotect";
+  const script = "Add-Type -AssemblyName System.Security; $inputText=[Console]::In.ReadToEnd(); $bytes=[Convert]::FromBase64String($inputText); $result=[Security.Cryptography.ProtectedData]::" + operation + "($bytes,$null,[Security.Cryptography.DataProtectionScope]::CurrentUser); [Console]::Out.Write([Convert]::ToBase64String($result))";
+  return new Promise((resolve, reject) => {
+    const child = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
+    let output = "", errors = "";
+    child.stdout.on("data", (d) => output += d);
+    child.stderr.on("data", (d) => errors += d);
+    child.on("error", reject);
+    child.on("close", (code) => code === 0 ? resolve(Buffer.from(output.trim(), "base64")) : reject(new Error("Windows key protection failed: " + errors.slice(0, 300))));
+    child.stdin.end(input.toString("base64"));
+  });
+}
+async function saveIdentity(filename, config) {
+  await fs.mkdir(path.dirname(filename), { recursive: true, mode: 448 });
+  const bytes = Buffer.from(JSON.stringify(config));
+  const record = process.platform === "win32" ? { format: "dpapi-current-user-v1", blob: (await dpapi("protect", bytes)).toString("base64") } : { format: "posix-owner-only-v1", config };
+  await fs.writeFile(filename, JSON.stringify(record), { mode: 384, flag: "wx" });
+  if (process.platform === "win32") {
+    const { stdout } = await run("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", "[System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value"]);
+    await run("icacls.exe", [filename, "/inheritance:r", "/grant:r", "*" + stdout.trim() + ":F"], { windowsHide: true });
+  } else await fs.chmod(filename, 384);
+}
+async function loadIdentity(filename) {
+  const record = JSON.parse(await fs.readFile(filename, "utf8"));
+  if (record.format === "dpapi-current-user-v1") {
+    if (process.platform !== "win32") throw new Error("Windows identity cannot be moved to another OS/user");
+    return JSON.parse((await dpapi("unprotect", Buffer.from(record.blob, "base64"))).toString("utf8"));
+  }
+  if (record.format === "posix-owner-only-v1" && process.platform !== "win32") {
+    const stat = await fs.stat(filename);
+    if ((stat.mode & 63) !== 0) throw new Error("Identity file must be owner-only (chmod 600)");
+    return record.config;
+  }
+  throw new Error("Unsupported identity format");
+}
+
+// src/agent/client.mjs
+import { WebSocket as WebSocket2 } from "ws";
+import { sign } from "node:crypto";
+
+// src/relay.mjs
+import { WebSocketServer, WebSocket } from "ws";
+
+// src/security.mjs
+import { randomBytes, randomUUID, createHash, timingSafeEqual, scrypt as scryptCallback } from "node:crypto";
+import { promisify as promisify2 } from "node:util";
+var scrypt = promisify2(scryptCallback);
+
+// src/relay.mjs
+var proofMessage = (deviceId, nonce) => "cetrix-agent-v1\n" + deviceId + "\n" + nonce;
+
+// src/agent/runtime.mjs
+init_files();
+import fs6 from "node:fs/promises";
+import path8 from "node:path";
+import os from "node:os";
+import dns from "node:dns/promises";
+import https from "node:https";
+import net from "node:net";
+
+// src/agent/filesystem-extra.mjs
+init_files();
+import fs3 from "node:fs/promises";
+import path3 from "node:path";
+import { constants as constants2 } from "node:fs";
+import { randomUUID as randomUUID2 } from "node:crypto";
+var TEXT_BYTES = 72 * 1024;
+var RESULT_BYTES = 640 * 1024;
+var SCAN_BYTES = 128 * 1024 * 1024;
+var EDIT_BYTES = 8 * 1024 * 1024;
+var WRITE_BYTES = 256 * 1024;
+var NOFOLLOW = constants2.O_NOFOLLOW || 0;
+var CHUNK_BYTES = 64 * 1024;
+function requestedPath(args, fallback) {
+  return args.path ?? args.file_path ?? args.filePath ?? fallback;
+}
+function writeAllowed(config) {
+  if (!config.allowWrite) throw new Error("File writes are disabled on this PC");
+}
+function integer(value, fallback, min, max, label) {
+  if (value === void 0) return fallback;
+  if (!Number.isSafeInteger(value) || value < min || value > max) throw new Error(`Invalid ${label}: expected an integer from ${min} to ${max}`);
+  return value;
+}
+function utf8(buffer, incomplete = false) {
+  if (buffer.includes(0)) throw new Error("Binary file not supported by text tools");
+  try {
+    return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(buffer, { stream: incomplete });
+  } catch {
+    throw new Error("Only valid UTF-8 text is supported by text tools");
+  }
+}
+function relative(root, target) {
+  return path3.relative(root, target).replaceAll(path3.sep, "/") || ".";
+}
+function resultSize(value) {
+  return Buffer.byteLength(JSON.stringify(value));
+}
+async function openText(config, requested2) {
+  const target = await safePath(config, requested2);
+  const handle = await fs3.open(target, constants2.O_RDONLY | NOFOLLOW);
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile()) throw new Error("Expected a regular file");
+    return { target, handle, stat };
+  } catch (error) {
+    await handle.close();
+    throw error;
+  }
+}
+async function* lines(handle, size, start2 = 0) {
+  let position = start2, lineStart = start2, pieces = [], kept = 0, lineBytes = 0;
+  while (position < size) {
+    if (position - start2 >= SCAN_BYTES) throw new Error("Text scan exceeds 128 MiB; use a smaller offset or a negative offset to read the tail");
+    const buffer = Buffer.allocUnsafe(Math.min(CHUNK_BYTES, size - position, SCAN_BYTES - (position - start2)));
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+    if (!bytesRead) break;
+    const chunk = buffer.subarray(0, bytesRead);
+    if (chunk.includes(0)) throw new Error("Binary file not supported by text tools");
+    let begin = 0;
+    while (begin < chunk.length) {
+      const newline = chunk.indexOf(10, begin);
+      const end = newline === -1 ? chunk.length : newline;
+      const part = chunk.subarray(begin, end);
+      if (kept < TEXT_BYTES) {
+        const prefix = part.subarray(0, TEXT_BYTES - kept);
+        pieces.push(prefix);
+        kept += prefix.length;
+      }
+      lineBytes += part.length;
+      if (newline === -1) break;
+      let text = utf8(Buffer.concat(pieces, kept), lineBytes > kept);
+      if (lineBytes === kept && text.endsWith("\r")) text = text.slice(0, -1);
+      yield { text, truncated: lineBytes > kept, byteStart: lineStart, byteEnd: position + newline + 1, newline: true };
+      lineStart = position + newline + 1;
+      pieces = [];
+      kept = 0;
+      lineBytes = 0;
+      begin = newline + 1;
+    }
+    position += bytesRead;
+  }
+  if (lineStart < position) yield { text: utf8(Buffer.concat(pieces, kept), lineBytes > kept), truncated: lineBytes > kept, byteStart: lineStart, byteEnd: position, newline: false };
+}
+async function tailStart(handle, size, count) {
+  let position = size, found = 0, scanned = 0;
+  while (position > 0) {
+    if (scanned >= SCAN_BYTES) throw new Error("Requested tail exceeds the 128 MiB scan limit");
+    const length = Math.min(CHUNK_BYTES, position, SCAN_BYTES - scanned);
+    position -= length;
+    const buffer = Buffer.allocUnsafe(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, position);
+    if (!bytesRead) break;
+    for (let index = bytesRead - 1; index >= 0; index--) {
+      if (buffer[index] === 10 && position + index !== size - 1 && ++found === count) return position + index + 1;
+    }
+    scanned += bytesRead;
+  }
+  return 0;
+}
+async function readFile(config, args) {
+  const requested2 = requestedPath(args);
+  const offset = integer(args.offset, 0, -1e6, 1e7, "offset");
+  const configuredLimit = integer(config.fileReadLineLimit, 1e3, 1, 1e4, "fileReadLineLimit");
+  const length = integer(args.length, configuredLimit, 1, 1e4, "length");
+  const limit = Math.min(length, configuredLimit);
+  const { handle, stat } = await openText(config, requested2);
+  try {
+    const byteStart = offset < 0 ? await tailStart(handle, stat.size, -offset) : 0;
+    let index = 0, count = 0, content = "", contentBytes = 0, lastByte = byteStart;
+    let lineTruncated = false, truncated = false;
+    for await (const line of lines(handle, stat.size, byteStart)) {
+      if (offset >= 0 && index++ < offset) {
+        lastByte = line.byteEnd;
+        continue;
+      }
+      const separator = count ? "\n" : "";
+      const bytes = Buffer.byteLength(separator + line.text);
+      if (count >= limit || contentBytes + bytes > TEXT_BYTES) {
+        truncated = true;
+        break;
+      }
+      content += separator + line.text;
+      contentBytes += bytes;
+      count++;
+      lineTruncated ||= line.truncated;
+      lastByte = line.byteEnd;
+      if (line.truncated) {
+        truncated = true;
+        break;
+      }
+      if (count >= limit) {
+        truncated = lastByte < stat.size;
+        break;
+      }
+    }
+    if (count && !lineTruncated && lastByte > 0 && contentBytes < TEXT_BYTES) {
+      const byte = Buffer.alloc(1);
+      await handle.read(byte, 0, 1, lastByte - 1);
+      if (byte[0] === 10) {
+        content += "\n";
+        contentBytes++;
+      }
+    }
+    return {
+      path: requested2,
+      content,
+      bytes: contentBytes,
+      fileSize: stat.size,
+      offset,
+      startLine: offset >= 0 ? offset + 1 : byteStart === 0 ? 1 : null,
+      linesRead: count,
+      nextOffset: lineTruncated ? null : offset < 0 ? byteStart === 0 ? count : Math.min(0, offset + count) : offset + count,
+      truncated: truncated || lineTruncated,
+      lineTruncated,
+      effectiveLength: limit,
+      ...lineTruncated ? { note: "One line exceeds the text output limit; nextOffset is unavailable because the line is incomplete." } : {}
+    };
+  } finally {
+    await handle.close();
+  }
+}
+async function listDirectory(config, args) {
+  const requested2 = requestedPath(args, ".");
+  const depth = integer(args.depth, 2, 1, 8, "depth");
+  const root = await fs3.realpath(config.root), target = await safePath(config, requested2);
+  if (!(await fs3.stat(target)).isDirectory()) throw new Error("Expected a directory");
+  const entries = [], visited = /* @__PURE__ */ new Set([target]);
+  let budget = 256, truncated = false;
+  async function visit(directory, level) {
+    const iterator = await fs3.opendir(directory);
+    try {
+      for await (const entry of iterator) {
+        if (entries.length >= 2e3) {
+          truncated = true;
+          break;
+        }
+        const candidate = path3.join(directory, entry.name);
+        let resolved;
+        try {
+          resolved = await safePath(config, relative(root, candidate));
+        } catch {
+          continue;
+        }
+        const item = { name: entry.name, path: relative(target, candidate), type: entry.isSymbolicLink() ? "symlink" : entry.isDirectory() ? "directory" : "file" };
+        const size = resultSize(item) + 1;
+        if (budget + size > RESULT_BYTES) {
+          truncated = true;
+          break;
+        }
+        entries.push(item);
+        budget += size;
+        if (entry.isDirectory() && level < depth && !visited.has(resolved)) {
+          visited.add(resolved);
+          await visit(resolved, level + 1);
+          if (truncated) break;
+        }
+      }
+    } finally {
+      await iterator.close().catch((error) => {
+        if (error.code !== "ERR_DIR_CLOSED") throw error;
+      });
+    }
+  }
+  await visit(target, 1);
+  return { path: requested2, entries, depth, truncated, maxEntries: 2e3 };
+}
+async function getFileInfo(config, args) {
+  const requested2 = requestedPath(args), target = await safePath(config, requested2), stat = await fs3.stat(target);
+  const result = {
+    path: requested2,
+    type: stat.isDirectory() ? "directory" : stat.isFile() ? "file" : "other",
+    size: stat.size,
+    created: stat.birthtime.toISOString(),
+    modified: stat.mtime.toISOString(),
+    accessed: stat.atime.toISOString(),
+    mode: stat.mode & 511,
+    permissions: (stat.mode & 511).toString(8)
+  };
+  if (!stat.isFile()) return result;
+  const { handle } = await openText(config, requested2);
+  try {
+    let lineCount = 0, lastLine = "", lastNewline = false, lineTruncated = false;
+    if (stat.size <= SCAN_BYTES) {
+      for await (const line of lines(handle, stat.size)) {
+        lineCount++;
+        lastLine = line.text;
+        lastNewline = line.newline;
+        lineTruncated = line.truncated;
+      }
+    } else {
+      lineCount = null;
+      const start2 = await tailStart(handle, stat.size, 1);
+      for await (const line of lines(handle, stat.size, start2)) {
+        lastLine = line.text;
+        lastNewline = line.newline;
+        lineTruncated = line.truncated;
+      }
+    }
+    return {
+      ...result,
+      lineCount,
+      lastLine: lineCount === null ? null : Math.max(0, lineCount - 1),
+      lastLineText: lastLine,
+      lastLineTruncated: lineTruncated,
+      appendPosition: { byteOffset: stat.size, line: lineCount === null ? null : lastNewline || !lineCount ? lineCount + 1 : lineCount, column: lineTruncated ? null : lastNewline ? 0 : lastLine.length },
+      ...lineCount === null ? { note: "Line counting is limited to 128 MiB; byteOffset remains exact." } : {}
+    };
+  } catch (error) {
+    if (/Binary file|valid UTF-8/.test(error.message)) return { ...result, text: false, lineCount: null, lastLine: null, lastLineText: null, appendPosition: { byteOffset: stat.size, line: null, column: null } };
+    if (/128 MiB/.test(error.message)) return { ...result, lineCount: null, lastLine: null, lastLineText: null, appendPosition: { byteOffset: stat.size, line: null, column: null }, note: error.message };
+    throw error;
+  } finally {
+    await handle.close();
+  }
+}
+async function writeFile(config, args) {
+  writeAllowed(config);
+  if (typeof args.content !== "string" || args.content.includes("\0") || Buffer.byteLength(args.content) > WRITE_BYTES) throw new Error("Expected UTF-8 text content up to 256 KiB without NUL bytes");
+  const mode = args.mode ?? "create";
+  if (!["create", "rewrite", "append"].includes(mode)) throw new Error("mode must be create, rewrite or append");
+  const target = await safePath(config, requestedPath(args), { write: true });
+  const append2 = mode === "append", overwrite = args.overwrite === true || mode === "rewrite";
+  const flags = constants2.O_WRONLY | constants2.O_CREAT | NOFOLLOW | (append2 ? constants2.O_APPEND : overwrite ? constants2.O_TRUNC : constants2.O_EXCL);
+  const handle = await fs3.open(target, flags, 384);
+  try {
+    await handle.writeFile(args.content, "utf8");
+  } finally {
+    await handle.close();
+  }
+  return { written: true, bytes: Buffer.byteLength(args.content), mode: append2 ? "append" : overwrite ? "rewrite" : "create" };
+}
+async function readEditable(config, requested2) {
+  const { handle, stat, target } = await openText(config, requested2);
+  try {
+    if (stat.size > EDIT_BYTES) throw new Error("edit_block supports files up to 8 MiB");
+    const buffer = Buffer.alloc(Math.min(EDIT_BYTES + 1, stat.size + 1));
+    let bytes = 0;
+    while (bytes < buffer.length) {
+      const read = await handle.read(buffer, bytes, buffer.length - bytes, bytes);
+      if (!read.bytesRead) break;
+      bytes += read.bytesRead;
+    }
+    if (bytes > stat.size) throw new Error("File changed while being read; retry the edit");
+    return { target, stat, text: utf8(buffer.subarray(0, bytes)) };
+  } finally {
+    await handle.close();
+  }
+}
+async function editBlock(config, args) {
+  writeAllowed(config);
+  const oldText = args.old_string ?? args.oldString, newText = args.new_string ?? args.newString;
+  if (typeof oldText !== "string" || !oldText.length || typeof newText !== "string" || oldText.includes("\0") || newText.includes("\0") || Buffer.byteLength(oldText) + Buffer.byteLength(newText) > WRITE_BYTES) throw new Error("Expected nonempty old_string and UTF-8 new_string, together up to 256 KiB");
+  const expected = integer(args.expected_replacements ?? args.expectedReplacements, 1, 1, 1e4, "expected_replacements");
+  const requested2 = requestedPath(args);
+  const { target, stat, text } = await readEditable(config, requested2);
+  let count = 0, position = 0;
+  while ((position = text.indexOf(oldText, position)) !== -1) {
+    count++;
+    position += oldText.length;
+  }
+  if (count !== expected) throw new Error(`Expected ${expected} exact replacement(s), found ${count}; no changes made`);
+  const updated = text.replaceAll(oldText, () => newText);
+  if (Buffer.byteLength(updated) > EDIT_BYTES) throw new Error("Result exceeds the 8 MiB edit limit; no changes made");
+  const temporary = path3.join(path3.dirname(target), `.cetrix-edit-${randomUUID2()}.tmp`);
+  try {
+    await fs3.writeFile(temporary, updated, { encoding: "utf8", flag: "wx", mode: stat.mode & 511 });
+    const checked = await safePath(config, requested2);
+    const current = await fs3.stat(checked);
+    if (checked !== target || current.size !== stat.size || current.mtimeMs !== stat.mtimeMs || current.ino !== stat.ino) throw new Error("File changed while preparing the edit; no changes made");
+    await fs3.rename(temporary, target);
+    return { edited: true, replacements: count, bytes: Buffer.byteLength(updated) };
+  } finally {
+    await fs3.unlink(temporary).catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+    });
+  }
+}
+async function createDirectory(config, args) {
+  writeAllowed(config);
+  const requested2 = requestedPath(args);
+  await safePath(config, requested2, { write: true }).catch((error) => {
+    if (error.code !== "ENOENT") throw error;
+  });
+  const parts = requested2.replaceAll("\\", "/").split("/").filter((part) => part && part !== ".");
+  let created = false;
+  for (let i = 1; i <= parts.length; i++) {
+    const target = await safePath(config, parts.slice(0, i).join("/"), { write: true });
+    try {
+      await fs3.mkdir(target, { mode: 448 });
+      created = true;
+    } catch (error) {
+      if (error.code !== "EEXIST" || !(await fs3.stat(target)).isDirectory()) throw error;
+    }
+  }
+  return { created, path: requested2 };
+}
+async function moveFile(config, args) {
+  writeAllowed(config);
+  const sourcePath = args.source ?? args.source_path ?? args.sourcePath ?? requestedPath(args);
+  const destinationPath = args.destination ?? args.destination_path ?? args.destinationPath ?? args.new_path ?? args.newPath;
+  const source = await safePath(config, sourcePath), destination = await safePath(config, destinationPath, { write: true });
+  const root = await fs3.realpath(config.root);
+  if (source === root || destination === root) throw new Error("Cannot move or replace the approved root");
+  const stat = await fs3.lstat(path3.resolve(root, sourcePath));
+  if (stat.isSymbolicLink()) throw new Error("Moving symlinks is not supported");
+  await fs3.lstat(destination).then(() => {
+    throw new Error("Destination already exists; no changes made");
+  }, (error) => {
+    if (error.code !== "ENOENT") throw error;
+  });
+  if (stat.isDirectory()) {
+    const descendant = path3.relative(source, destination);
+    if (!descendant.startsWith(".." + path3.sep) && descendant !== ".." && !path3.isAbsolute(descendant)) throw new Error("Cannot move a directory inside itself");
+    let checked = 0;
+    async function inspect(directory) {
+      const iterator = await fs3.opendir(directory);
+      for await (const entry of iterator) {
+        if (++checked > 1e4) throw new Error("Directory move exceeds the 10,000 entry validation limit");
+        const child = path3.join(directory, entry.name);
+        await safePath(config, relative(root, child));
+        if (entry.isSymbolicLink()) throw new Error("Directory moves containing symlinks are not supported");
+        const future = path3.join(destination, path3.relative(source, child));
+        await safePath(config, relative(root, future), { write: true }).catch((error) => {
+          if (error.code !== "ENOENT") throw error;
+        });
+        for (const deniedPath of config.deniedPaths || []) {
+          const denied = await fs3.realpath(deniedPath).catch(() => path3.resolve(deniedPath));
+          const inside = path3.relative(denied, future);
+          if (inside === "" || inside !== ".." && !inside.startsWith(".." + path3.sep) && !path3.isAbsolute(inside)) throw new Error("Agent/server credentials are protected");
+        }
+        if (entry.isDirectory()) await inspect(child);
+      }
+    }
+    await inspect(source);
+    await fs3.rename(source, destination);
+  } else if (stat.isFile()) {
+    await fs3.link(source, destination);
+    try {
+      await fs3.unlink(source);
+    } catch (error) {
+      await fs3.unlink(destination);
+      throw error;
+    }
+  } else throw new Error("Only regular files and directories can be moved");
+  return { moved: true, source: sourcePath, destination: destinationPath };
+}
+async function executeFilesystemTool(config, tool2, args = {}) {
+  if (tool2 === "list_directory") return listDirectory(config, args);
+  if (tool2 === "read_file") return readFile(config, args);
+  if (tool2 === "get_file_info") return getFileInfo(config, args);
+  if (tool2 === "write_file") return writeFile(config, args);
+  if (tool2 === "edit_block") return editBlock(config, args);
+  if (tool2 === "create_directory") return createDirectory(config, args);
+  if (tool2 === "move_file") return moveFile(config, args);
+  if (tool2 === "read_multiple_files") {
+    if (!Array.isArray(args.paths) || !args.paths.length || args.paths.length > 100) throw new Error("paths must contain 1 to 100 relative file paths");
+    const files = [];
+    let bytes = 256, truncated = false;
+    for (const requested2 of args.paths) {
+      let result;
+      try {
+        result = await readFile(config, { ...args, path: requested2 });
+      } catch (error) {
+        result = { path: typeof requested2 === "string" ? requested2 : null, error: error.message };
+      }
+      const size = resultSize(result) + 1;
+      if (bytes + size > RESULT_BYTES) {
+        truncated = true;
+        break;
+      }
+      files.push(result);
+      bytes += size;
+    }
+    return { files, truncated, nextIndex: truncated ? files.length : null };
+  }
+  throw new Error("Unsupported filesystem tool");
+}
+
+// src/agent/processes.mjs
+init_files();
+import { spawn as spawn3 } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+import { EventEmitter } from "node:events";
+var states = /* @__PURE__ */ new WeakMap();
+var MAX_OUTPUT = 262144;
+var MAX_PAGE_CHARS = 65536;
+var MAX_SESSIONS = 32;
+var MAX_RUNNING = 8;
+var IDLE_TTL = 10 * 6e4;
+var MAX_RUNTIME = 60 * 6e4;
+function stateFor(config) {
+  if (!states.has(config)) states.set(config, { sessions: /* @__PURE__ */ new Map(), generation: 0, grantGenerations: /* @__PURE__ */ new Map() });
+  return states.get(config);
+}
+var owner = (context) => String(context.grantId ?? "local");
+var grantGeneration = (state2, grantId) => state2.grantGenerations.get(grantId) || 0;
+function number(value, fallback, min, max) {
+  if (value === void 0) return fallback;
+  if (!Number.isInteger(value) || value < min || value > max) throw new Error(`Expected an integer between ${min} and ${max}`);
+  return value;
+}
+function permission(config) {
+  if (!config.allowShell) throw new Error("Shell execution is disabled on this PC");
+}
+function checkActive(context) {
+  if (context.signal?.aborted || context.isActive?.() === false) throw new Error("Agent connection or authorization closed");
+}
+function checkCommand(config, command) {
+  const tokens = command.toLowerCase().match(/[a-z0-9_.-]+/g) || [];
+  for (const blocked of config.blockedCommands || []) {
+    if (typeof blocked !== "string" || !blocked.trim()) continue;
+    const expected = blocked.toLowerCase().match(/[a-z0-9_.-]+/g) || [];
+    if (expected.length && tokens.some((_, index) => expected.every((token, offset) => tokens[index + offset] === token))) throw new Error("Command is blocked by this PC configuration");
+  }
+}
+function sessionFor(state2, pid, grantId) {
+  const session = state2.sessions.get(number(pid, void 0, 1, 2147483647));
+  if (!session || session.grantId !== grantId) throw new Error("Terminal session not found for this authorization");
+  session.touched = Date.now();
+  return session;
+}
+function append(session, text) {
+  if (!text) return;
+  session.output += text;
+  if (session.output.length > MAX_OUTPUT) {
+    let drop = session.output.length - MAX_OUTPUT;
+    const newline = session.output.indexOf("\n", drop);
+    if (newline >= 0 && newline - drop < MAX_OUTPUT / 4) drop = newline + 1;
+    session.baseLine += (session.output.slice(0, drop).match(/\n/g) || []).length;
+    session.baseChar += drop;
+    session.output = session.output.slice(drop);
+    session.truncated = true;
+  }
+  session.changed = Date.now();
+  session.events.emit("change");
+}
+function summary(session) {
+  return {
+    pid: session.pid,
+    sessionId: String(session.pid),
+    command: session.command.slice(0, 1024),
+    commandTruncated: session.command.length > 1024,
+    cwd: session.cwd,
+    status: session.status,
+    runtimeMs: Date.now() - session.createdAt,
+    exitCode: session.exitCode,
+    signal: session.signal,
+    terminated: session.terminated,
+    outputTruncated: session.truncated,
+    waitingForInput: session.status === "running" && /(?:^|\n)(?:>>>|\.\.\.|>|\$|[^\n]*[>$#])\s*$/.test(session.output.slice(-200))
+  };
+}
+function outputPage(session, args = {}, config = {}) {
+  const offset = number(args.offset, 0, -1e8, 1e8), length = Math.min(number(args.length, config.fileReadLineLimit || 1e3, 1, 2e3), config.fileReadLineLimit || 2e3);
+  const all = session.output.split("\n");
+  if (all.at(-1) === "") all.pop();
+  let start2, output, line;
+  if (offset === 0) {
+    start2 = Math.max(session.cursor - session.baseChar, 0);
+    const remaining = session.output.slice(start2), chunks = remaining.split("\n");
+    output = chunks.slice(0, length).join("\n");
+    if (chunks.length > length) output += "\n";
+    line = session.baseLine + (session.output.slice(0, start2).match(/\n/g) || []).length;
+  } else {
+    start2 = offset < 0 ? Math.max(0, all.length + offset) : Math.max(0, offset - session.baseLine);
+    output = all.slice(start2, start2 + length).join("\n");
+    line = session.baseLine + start2;
+  }
+  const pageTruncated = output.length > MAX_PAGE_CHARS;
+  output = output.slice(0, MAX_PAGE_CHARS);
+  if (offset === 0) session.cursor = session.baseChar + start2 + output.length;
+  const linesRead = output ? output.split("\n").length - (output.endsWith("\n") ? 1 : 0) : 0;
+  return {
+    ...summary(session),
+    output,
+    offset: line,
+    linesRead,
+    nextOffset: line + linesRead,
+    totalLines: session.baseLine + all.length,
+    firstAvailableLine: session.baseLine,
+    pageTruncated,
+    hasMore: offset === 0 ? session.cursor < session.baseChar + session.output.length : pageTruncated || line + linesRead < session.baseLine + all.length
+  };
+}
+async function waitOutput(session, timeout) {
+  if (!timeout || session.status !== "running") return;
+  const started = Date.now();
+  await new Promise((resolve) => {
+    let timer;
+    const finish2 = () => {
+      clearTimeout(timer);
+      session.events.off("change", check);
+      resolve();
+    };
+    const check = () => {
+      clearTimeout(timer);
+      if (session.status !== "running" || Date.now() - started >= timeout) return finish2();
+      if (session.baseChar + session.output.length > session.cursor && Date.now() - session.changed >= 120) return finish2();
+      timer = setTimeout(check, Math.min(120, timeout - (Date.now() - started)));
+    };
+    session.events.on("change", check);
+    check();
+  });
+}
+async function waitFinished(session, timeout = 2e3) {
+  if (session.status !== "running") return;
+  await new Promise((resolve) => {
+    const finish2 = () => {
+      clearTimeout(timer);
+      session.events.off("change", check);
+      resolve();
+    };
+    const check = () => {
+      if (session.status !== "running") finish2();
+    };
+    const timer = setTimeout(finish2, timeout);
+    session.events.on("change", check);
+    check();
+  });
+}
+function killTree(session, reason = "terminated") {
+  if (session.status !== "running") return;
+  session.terminated = true;
+  session.terminationReason = reason;
+  if (process.platform === "win32") {
+    const killer = spawn3("taskkill", ["/PID", String(session.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
+    killer.on("error", () => session.child.kill("SIGKILL"));
+    killer.on("exit", (code) => {
+      if (code && session.status === "running") session.child.kill("SIGKILL");
+    });
+  } else {
+    try {
+      process.kill(-session.pid, "SIGKILL");
+    } catch {
+      session.child.kill("SIGKILL");
+    }
+  }
+}
+function shellCommand(command, shell) {
+  const chosen = (shell || (process.platform === "win32" ? "powershell" : "sh")).toLowerCase();
+  if (["powershell", "powershell.exe", "pwsh", "pwsh.exe"].includes(chosen)) return [chosen.startsWith("pwsh") ? "pwsh" : "powershell.exe", ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", command]];
+  if (["cmd", "cmd.exe"].includes(chosen)) return ["cmd.exe", ["/d", "/s", "/c", command]];
+  if (["sh", "bash", "zsh"].includes(chosen)) return [chosen, ["-c", command]];
+  if (["/bin/sh", "/bin/bash", "/bin/zsh"].includes(chosen)) return [chosen, ["-c", command]];
+  throw new Error("Unsupported shell; use powershell, pwsh, cmd, sh, bash or zsh");
+}
+function expire(state2) {
+  for (const session of state2.sessions.values()) {
+    if (Date.now() - session.touched > IDLE_TTL || Date.now() - session.createdAt > MAX_RUNTIME) {
+      killTree(session, "session expired");
+      clearInterval(session.expiry);
+      state2.sessions.delete(session.pid);
+    }
+  }
+}
+async function start(config, args, context, state2) {
+  if (typeof args.command !== "string" || !args.command.trim() || args.command.length > 65536 || args.command.includes("\0")) throw new Error("Invalid command");
+  checkCommand(config, args.command);
+  const timeout = number(args.timeout_ms, 1e3, 0, 25e3), generation = state2.generation, grantId = owner(context), grantLease = grantGeneration(state2, grantId);
+  const cwd = await safePath(config, args.cwd || ".");
+  if (generation !== state2.generation || grantLease !== grantGeneration(state2, grantId)) throw new Error("Agent connection or authorization closed");
+  checkActive(context);
+  expire(state2);
+  if ([...state2.sessions.values()].filter((s) => s.status === "running").length >= MAX_RUNNING) throw new Error("Maximum of 8 running terminal sessions reached");
+  if (state2.sessions.size >= MAX_SESSIONS) {
+    const finished = [...state2.sessions.values()].find((s) => s.status !== "running");
+    if (!finished) throw new Error("Terminal session limit reached");
+    clearInterval(finished.expiry);
+    state2.sessions.delete(finished.pid);
+  }
+  const [exe, argv] = shellCommand(args.command, args.shell || config.defaultShell);
+  const child = spawn3(exe, argv, { cwd, windowsHide: true, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"] });
+  const session = {
+    child,
+    pid: child.pid,
+    grantId: owner(context),
+    command: args.command,
+    cwd: args.cwd || ".",
+    createdAt: Date.now(),
+    touched: Date.now(),
+    changed: 0,
+    status: "running",
+    exitCode: null,
+    signal: null,
+    terminated: false,
+    output: "",
+    baseLine: 0,
+    baseChar: 0,
+    cursor: 0,
+    truncated: false,
+    events: new EventEmitter()
+  };
+  const stdout = new StringDecoder("utf8"), stderr = new StringDecoder("utf8");
+  child.stdout.on("data", (data) => append(session, stdout.write(data)));
+  child.stderr.on("data", (data) => append(session, stderr.write(data)));
+  child.stdin.on("error", () => {
+  });
+  child.on("error", (error) => {
+    session.status = "failed";
+    append(session, error.message);
+    session.events.emit("change");
+  });
+  child.on("close", (code, signal) => {
+    append(session, stdout.end() + stderr.end());
+    session.status = session.status === "failed" ? "failed" : "finished";
+    session.exitCode = code;
+    session.signal = signal;
+    session.events.emit("change");
+  });
+  if (session.pid) state2.sessions.set(session.pid, session);
+  try {
+    await new Promise((resolve, reject) => {
+      child.once("spawn", resolve);
+      child.once("error", reject);
+    });
+  } catch (error) {
+    state2.sessions.delete(session.pid);
+    throw error;
+  }
+  if (generation !== state2.generation || grantLease !== grantGeneration(state2, grantId) || context.signal?.aborted || context.isActive?.() === false) {
+    killTree(session, "authorization closed");
+    state2.sessions.delete(session.pid);
+    throw new Error("Agent connection or authorization closed");
+  }
+  session.expiry = setInterval(() => expire(state2), 3e4);
+  session.expiry.unref();
+  await waitOutput(session, timeout);
+  return outputPage(session, args, config);
+}
+async function listOSProcesses(state2, grantId) {
+  const windows = process.platform === "win32";
+  const exe = windows ? "powershell.exe" : "ps";
+  const args = windows ? ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", "@(Get-Process | Select-Object -First 1000 Id,ProcessName,CPU,WorkingSet64) | ConvertTo-Json -Compress"] : ["-eo", "pid=,comm=,pcpu=,rss="];
+  const output = await new Promise((resolve, reject) => {
+    const child = spawn3(exe, args, { windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    let data = "", failure = "", ended = false;
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish2(new Error("Process listing timed out"));
+    }, 5e3);
+    const finish2 = (error) => {
+      if (ended) return;
+      ended = true;
+      clearTimeout(timer);
+      if (error) reject(error);
+      else resolve(data);
+    };
+    child.stdout.on("data", (chunk) => {
+      data += chunk.toString();
+      if (data.length > 262144) {
+        child.kill("SIGKILL");
+        finish2(new Error("Process listing is too large"));
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      failure = (failure + chunk).slice(0, 1e3);
+    });
+    child.on("error", finish2);
+    child.on("close", (code) => finish2(code ? new Error(failure || "Process listing failed") : void 0));
+  });
+  let processes;
+  if (windows) {
+    const parsed = JSON.parse(output || "[]");
+    processes = (Array.isArray(parsed) ? parsed : [parsed]).map((p) => ({ pid: p.Id, name: p.ProcessName, cpuSeconds: p.CPU ?? null, memoryBytes: p.WorkingSet64 }));
+  } else processes = output.trim().split("\n").filter(Boolean).map((line) => {
+    const match = line.trim().match(/^(\d+)\s+(.+?)\s+([\d.]+)\s+(\d+)$/);
+    return match ? { pid: Number(match[1]), name: match[2], cpuPercent: Number(match[3]), memoryBytes: Number(match[4]) * 1024 } : null;
+  }).filter(Boolean);
+  return { processes: processes.slice(0, 1e3).map((p) => ({ ...p, owned: state2.sessions.get(p.pid)?.grantId === grantId })), truncated: processes.length >= 1e3, killPolicy: "Owned sessions can be terminated; external PIDs require confirm: true. Agent ancestors and other authorizations are protected." };
+}
+async function processParents() {
+  const windows = process.platform === "win32";
+  const executable = windows ? "powershell.exe" : "ps";
+  const args = windows ? ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command", "@(Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId) | ConvertTo-Json -Compress"] : ["-eo", "pid=,ppid="];
+  const output = await new Promise((resolve, reject) => {
+    const child = spawn3(executable, args, { windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    let data = "", done = false;
+    const finish2 = (error) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      if (error) reject(error);
+      else resolve(data);
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish2(new Error("Process ancestry inspection timed out"));
+    }, 5e3);
+    child.stdout.on("data", (chunk) => {
+      data += chunk;
+      if (data.length > 512 * 1024) {
+        child.kill("SIGKILL");
+        finish2(new Error("Process ancestry list is too large"));
+      }
+    });
+    child.on("error", finish2);
+    child.on("close", (code) => finish2(code ? new Error("Cannot inspect process ancestry safely") : void 0));
+  });
+  const parents = /* @__PURE__ */ new Map();
+  if (windows) {
+    const rows = JSON.parse(output || "[]");
+    for (const row of Array.isArray(rows) ? rows : [rows]) parents.set(Number(row.ProcessId), Number(row.ParentProcessId));
+  } else for (const line of output.trim().split("\n")) {
+    const match = line.trim().match(/^(\d+)\s+(\d+)$/);
+    if (match) parents.set(Number(match[1]), Number(match[2]));
+  }
+  return parents;
+}
+async function killExternalProcess(state2, args, grantId, context) {
+  const pid = number(args.pid, void 0, 1, 2147483647);
+  if (pid <= 1 || pid === process.pid || pid === process.ppid) throw new Error("Agent and ancestor processes are protected");
+  if (args.confirm !== true) throw new Error("Terminating an external process requires explicit confirm: true");
+  const generation = state2.generation, lease = grantGeneration(state2, grantId), parents = await processParents();
+  if (generation !== state2.generation || lease !== grantGeneration(state2, grantId)) throw new Error("Agent connection or authorization closed");
+  checkActive(context);
+  if (!parents.has(pid)) throw new Error("Process not found");
+  const seen = /* @__PURE__ */ new Set();
+  let ancestor = process.pid;
+  while (ancestor > 1 && !seen.has(ancestor)) {
+    if (ancestor === pid) throw new Error("Agent and ancestor processes are protected");
+    seen.add(ancestor);
+    const parent = parents.get(ancestor);
+    if (parent === void 0) break;
+    ancestor = parent;
+  }
+  seen.clear();
+  ancestor = pid;
+  while (ancestor > 1 && !seen.has(ancestor)) {
+    const managed = state2.sessions.get(ancestor);
+    if (managed && managed.grantId !== grantId) throw new Error("Process belongs to another authorization");
+    seen.add(ancestor);
+    ancestor = parents.get(ancestor) || 0;
+  }
+  process.kill(pid, "SIGKILL");
+  return { pid, terminationRequested: true, external: true, scope: "Only the explicitly confirmed PID was signaled; OS permissions apply" };
+}
+async function executeProcessTool(config, tool2, args = {}, context = {}) {
+  permission(config);
+  checkActive(context);
+  const state2 = stateFor(config), grantId = owner(context);
+  expire(state2);
+  if (tool2 === "start_process") return start(config, args, context, state2);
+  if (tool2 === "list_sessions") return { sessions: [...state2.sessions.values()].filter((s) => s.grantId === grantId).map(summary) };
+  if (tool2 === "list_processes") return listOSProcesses(state2, grantId);
+  if (tool2 === "kill_process" && !state2.sessions.has(args.pid)) return killExternalProcess(state2, args, grantId, context);
+  const session = sessionFor(state2, args.pid, grantId);
+  if (tool2 === "force_terminate" || tool2 === "kill_process") {
+    killTree(session);
+    await waitFinished(session);
+    return { ...summary(session), terminationRequested: true };
+  }
+  if (tool2 === "interact_with_process") {
+    if (session.status !== "running") throw new Error("Terminal session has finished");
+    if (typeof args.input !== "string" || Buffer.byteLength(args.input) > 65536) throw new Error("Process input must be text up to 64 KiB");
+    checkCommand(config, args.input);
+    const input = args.input.endsWith("\n") ? args.input : args.input + "\n";
+    await new Promise((resolve, reject) => session.child.stdin.write(input, (error) => error ? reject(error) : resolve()));
+    await waitOutput(session, number(args.timeout_ms, 1e3, 0, 25e3));
+    return outputPage(session, args, config);
+  }
+  if (tool2 === "read_process_output") {
+    if (!args.offset) await waitOutput(session, number(args.timeout_ms, 1e3, 0, 25e3));
+    return outputPage(session, args, config);
+  }
+  throw new Error("Unknown process tool");
+}
+async function cleanupProcessSessions(config, { grantId, sessionId } = {}) {
+  const state2 = states.get(config);
+  if (!state2) return;
+  if (grantId !== void 0) state2.grantGenerations.set(String(grantId), grantGeneration(state2, String(grantId)) + 1);
+  else if (sessionId === void 0) {
+    state2.generation++;
+    state2.grantGenerations.clear();
+  }
+  const removed = [];
+  for (const [pid, session] of state2.sessions) {
+    if (grantId !== void 0 && session.grantId !== String(grantId)) continue;
+    if (sessionId !== void 0 && String(pid) !== String(sessionId)) continue;
+    killTree(session, "authorization or connection closed");
+    clearInterval(session.expiry);
+    state2.sessions.delete(pid);
+    removed.push(waitFinished(session));
+  }
+  await Promise.all(removed);
+}
+
+// src/agent/search.mjs
+init_files();
+import fs4 from "node:fs/promises";
+import { constants as constants3 } from "node:fs";
+import path4 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { Worker } from "node:worker_threads";
+var states2 = /* @__PURE__ */ new WeakMap();
+var MAX_RESULTS = 2e3;
+var MAX_VISITED = 1e4;
+var MAX_BYTES = 32 * 1024 * 1024;
+var MAX_FILE = 1024 * 1024;
+var MAX_RUNTIME2 = 3e4;
+var TTL = 5 * 6e4;
+var matcherSource = `
+const {parentPort,workerData}=require('node:worker_threads');
+const regex=workerData.literal?null:new RegExp(workerData.pattern,workerData.ignoreCase?'i':'');
+const pattern=workerData.ignoreCase?workerData.pattern.toLowerCase():workerData.pattern;
+parentPort.on('message',({id,text,limit})=>{
+  try {
+    const lines=text.split(/\\r?\\n/),matches=[];
+    for(let i=0;i<lines.length && matches.length<limit;i++) {
+      const haystack=workerData.ignoreCase?lines[i].toLowerCase():lines[i];
+      const match=regex?regex.exec(lines[i]):null;
+      const position=regex?(match?match.index:-1):haystack.indexOf(pattern);
+      if(position>=0)matches.push({line:i+1,column:position+1,content:lines[i].slice(Math.max(0,position-100),Math.max(0,position-100)+2000)});
+    }
+    parentPort.postMessage({id,matches});
+  } catch(error) {parentPort.postMessage({id,error:error.message});}
+});`;
+function stateFor2(config) {
+  if (!states2.has(config)) states2.set(config, { sessions: /* @__PURE__ */ new Map(), generation: 0, grantGenerations: /* @__PURE__ */ new Map() });
+  return states2.get(config);
+}
+var owner2 = (context) => String(context.grantId ?? "local");
+var grantGeneration2 = (state2, grantId) => state2.grantGenerations.get(grantId) || 0;
+function integer2(value, fallback, min, max) {
+  if (value === void 0) return fallback;
+  if (!Number.isInteger(value) || value < min || value > max) throw new Error(`Expected an integer between ${min} and ${max}`);
+  return value;
+}
+function glob(pattern, ignoreCase = true) {
+  const alternatives = pattern.split("|").map((part) => part.split("").map((c) => c === "*" ? ".*" : c === "?" ? "." : c.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(""));
+  return new RegExp("^(?:" + alternatives.join("|") + ")$", ignoreCase ? "i" : "");
+}
+function summary2(session) {
+  return {
+    sessionId: session.id,
+    path: session.path,
+    pattern: session.pattern,
+    searchType: session.searchType,
+    status: session.status,
+    runtimeMs: (session.finishedAt || Date.now()) - session.createdAt,
+    totalResults: session.results.length,
+    visited: session.visited,
+    skipped: session.skipped,
+    truncated: session.truncated,
+    reason: session.reason || null
+  };
+}
+function page(session, args = {}) {
+  const offset = integer2(args.offset, 0, -1e7, 1e7), length = Math.min(integer2(args.length, 100, 1, 2e3), 200);
+  const start2 = offset < 0 ? Math.max(0, session.results.length + offset) : offset;
+  const count = offset < 0 ? Math.min(-offset, 200) : length;
+  const results = [];
+  let bytes = 0;
+  for (const result of session.results.slice(start2, start2 + count)) {
+    const size = Buffer.byteLength(JSON.stringify(result));
+    if (bytes + size > 4e5) break;
+    results.push(result);
+    bytes += size;
+  }
+  return {
+    ...summary2(session),
+    results,
+    offset: start2,
+    nextOffset: start2 + results.length,
+    hasMore: start2 + results.length < session.results.length,
+    isComplete: session.status !== "running"
+  };
+}
+function finish(session, status, reason) {
+  if (session.status !== "running") return;
+  session.status = status;
+  session.reason = reason;
+  session.finishedAt = Date.now();
+  clearTimeout(session.deadline);
+  for (const pending of session.pending.values()) {
+    clearTimeout(pending.timer);
+    pending.reject(new Error(reason || "Search ended"));
+  }
+  session.pending.clear();
+  session.worker?.terminate();
+}
+function expire2(state2) {
+  for (const [id, session] of state2.sessions) if (session.finishedAt && Date.now() - session.finishedAt > TTL) {
+    clearTimeout(session.expiry);
+    state2.sessions.delete(id);
+  }
+}
+function active(session) {
+  return session.status === "running";
+}
+function matcher(session, options) {
+  const worker = new Worker(matcherSource, { eval: true, workerData: options, resourceLimits: { maxOldGenerationSizeMb: 32, maxYoungGenerationSizeMb: 8 } });
+  session.worker = worker;
+  worker.on("message", (message) => {
+    const pending = session.pending.get(message.id);
+    if (!pending) return;
+    session.pending.delete(message.id);
+    clearTimeout(pending.timer);
+    if (message.error) pending.reject(new Error(message.error));
+    else pending.resolve(message.matches);
+  });
+  const fail2 = (error) => {
+    for (const pending of session.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    session.pending.clear();
+  };
+  worker.on("error", fail2);
+  worker.on("exit", () => fail2(new Error("Search matcher stopped")));
+  return (text) => new Promise((resolve, reject) => {
+    if (!active(session)) {
+      reject(new Error("Search stopped"));
+      return;
+    }
+    const id = ++session.sequence;
+    const timer = setTimeout(() => {
+      session.pending.delete(id);
+      worker.terminate();
+      reject(new Error("Pattern matching exceeded its time limit"));
+    }, 1500);
+    session.pending.set(id, { resolve, reject, timer });
+    worker.postMessage({ id, text, limit: MAX_RESULTS - session.results.length });
+  });
+}
+async function search(config, session, args, initial) {
+  const ignoreCase = args.ignoreCase !== false;
+  let fileGlob;
+  if (args.searchType === "files" && !args.literalSearch && /^[*?]/.test(args.pattern)) fileGlob = glob(args.pattern, ignoreCase);
+  const filter = args.filePattern ? glob(args.filePattern, ignoreCase) : null;
+  const match = matcher(session, { pattern: fileGlob ? "" : args.pattern, literal: !!args.literalSearch, ignoreCase });
+  const visited = /* @__PURE__ */ new Set(), queue = [{ relative: session.path, resolved: initial, depth: 0 }];
+  const stopLimit = (reason) => {
+    session.truncated = true;
+    finish(session, "completed", reason);
+  };
+  try {
+    while (queue.length && active(session)) {
+      const entry = queue.pop();
+      if (++session.visited > MAX_VISITED) {
+        stopLimit("Traversal limit reached");
+        break;
+      }
+      let resolved, stat;
+      try {
+        resolved = await safePath(config, entry.relative);
+        stat = await fs4.stat(resolved);
+      } catch {
+        session.skipped++;
+        continue;
+      }
+      if (!active(session)) break;
+      if (visited.has(resolved)) {
+        session.skipped++;
+        continue;
+      }
+      visited.add(resolved);
+      if (stat.isDirectory()) {
+        if (entry.depth >= 64) {
+          session.skipped++;
+          continue;
+        }
+        let directory;
+        try {
+          directory = await fs4.opendir(resolved);
+        } catch {
+          session.skipped++;
+          continue;
+        }
+        try {
+          for await (const child of directory) {
+            if (!active(session)) break;
+            if (queue.length + session.visited >= MAX_VISITED) {
+              stopLimit("Traversal limit reached");
+              break;
+            }
+            queue.push({ relative: path4.join(entry.relative, child.name), depth: entry.depth + 1 });
+          }
+        } catch {
+          session.skipped++;
+        }
+        continue;
+      }
+      if (!stat.isFile()) continue;
+      const basename = path4.basename(entry.relative), relative2 = entry.relative.replaceAll("\\", "/").replace(/^\.\//, "");
+      if (filter && !filter.test(relative2) && !filter.test(basename)) continue;
+      if (session.searchType === "files") {
+        const matches = fileGlob ? fileGlob.test(basename) : (await match(basename)).length > 0;
+        if (!active(session)) break;
+        if (matches) session.results.push({ path: relative2, type: "file" });
+        if (matches && args.earlyTermination !== false && (ignoreCase ? basename.toLowerCase() === args.pattern.toLowerCase() : basename === args.pattern)) {
+          finish(session, "completed", "Exact filename found");
+          break;
+        }
+      } else {
+        if (stat.size > MAX_FILE) {
+          session.skipped++;
+          continue;
+        }
+        if (session.bytes + stat.size > MAX_BYTES) {
+          stopLimit("Search byte limit reached");
+          break;
+        }
+        let handle, text;
+        try {
+          handle = await fs4.open(resolved, constants3.O_RDONLY | (constants3.O_NOFOLLOW || 0));
+          const buffer = Buffer.alloc(MAX_FILE + 1), { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+          session.bytes += bytesRead;
+          if (bytesRead > MAX_FILE || buffer.subarray(0, bytesRead).includes(0)) {
+            session.skipped++;
+            continue;
+          }
+          text = buffer.subarray(0, bytesRead).toString("utf8");
+        } catch {
+          session.skipped++;
+          continue;
+        } finally {
+          await handle?.close();
+        }
+        if (!active(session)) break;
+        const matches = await match(text);
+        if (!active(session)) break;
+        for (const result of matches) session.results.push({ path: relative2, type: "content", ...result });
+        if (matches.length && args.earlyTermination === true) {
+          finish(session, "completed", "First matching file found");
+          break;
+        }
+      }
+      if (session.results.length >= MAX_RESULTS) {
+        stopLimit("Result limit reached");
+        break;
+      }
+    }
+    finish(session, "completed");
+  } catch (error) {
+    if (active(session)) finish(session, "failed", error.message);
+  } finally {
+    clearTimeout(session.deadline);
+    session.worker?.terminate();
+    session.expiry = setTimeout(() => stateFor2(config).sessions.delete(session.id), TTL);
+    session.expiry.unref();
+  }
+}
+async function executeSearchTool(config, tool2, args = {}, context = {}) {
+  if (context.signal?.aborted || context.isActive?.() === false) throw new Error("Agent connection or authorization closed");
+  const state2 = stateFor2(config), grantId = owner2(context);
+  expire2(state2);
+  if (tool2 === "list_searches") return { searches: [...state2.sessions.values()].filter((s) => s.grantId === grantId).map(summary2) };
+  if (tool2 === "start_search") {
+    if (typeof args.pattern !== "string" || !args.pattern || args.pattern.length > 1024) throw new Error("Search pattern must be 1 to 1024 characters");
+    if (!["files", "content"].includes(args.searchType)) throw new Error("searchType must be files or content");
+    if (args.filePattern !== void 0 && (typeof args.filePattern !== "string" || args.filePattern.length > 300)) throw new Error("Invalid filePattern");
+    if (!args.literalSearch && !(args.searchType === "files" && /^[*?]/.test(args.pattern))) new RegExp(args.pattern, args.ignoreCase !== false ? "i" : "");
+    if ([...state2.sessions.values()].filter((s) => s.status === "running").length >= 4) throw new Error("Maximum of 4 active searches reached");
+    if (state2.sessions.size >= 16) {
+      const done = [...state2.sessions.values()].find((s) => s.status !== "running");
+      if (!done) throw new Error("Search session limit reached");
+      clearTimeout(done.expiry);
+      state2.sessions.delete(done.id);
+    }
+    const generation = state2.generation, lease = grantGeneration2(state2, grantId), relative2 = args.path || ".", initial = await safePath(config, relative2);
+    if (generation !== state2.generation || lease !== grantGeneration2(state2, grantId) || context.signal?.aborted || context.isActive?.() === false) throw new Error("Agent connection or authorization closed");
+    if ([...state2.sessions.values()].filter((s) => s.status === "running").length >= 4) throw new Error("Maximum of 4 active searches reached");
+    const session2 = {
+      id: randomUUID3(),
+      grantId,
+      path: relative2,
+      pattern: args.pattern,
+      searchType: args.searchType,
+      status: "running",
+      createdAt: Date.now(),
+      results: [],
+      visited: 0,
+      skipped: 0,
+      bytes: 0,
+      truncated: false,
+      sequence: 0,
+      pending: /* @__PURE__ */ new Map()
+    };
+    state2.sessions.set(session2.id, session2);
+    session2.deadline = setTimeout(() => {
+      session2.truncated = true;
+      finish(session2, "completed", "Search time limit reached");
+    }, MAX_RUNTIME2);
+    session2.deadline.unref();
+    session2.task = search(config, session2, args, initial);
+    return page(session2);
+  }
+  const session = state2.sessions.get(args.sessionId);
+  if (!session || session.grantId !== grantId) throw new Error("Search session not found for this authorization");
+  if (tool2 === "get_more_search_results") return page(session, args);
+  if (tool2 === "stop_search") {
+    finish(session, "stopped", "Stopped by request");
+    return page(session, args);
+  }
+  throw new Error("Unknown search tool");
+}
+async function cleanupSearchSessions(config, { grantId, sessionId } = {}) {
+  const state2 = states2.get(config);
+  if (!state2) return;
+  if (grantId !== void 0) state2.grantGenerations.set(String(grantId), grantGeneration2(state2, String(grantId)) + 1);
+  else if (sessionId === void 0) {
+    state2.generation++;
+    state2.grantGenerations.clear();
+  }
+  for (const [id, session] of state2.sessions) {
+    if (grantId !== void 0 && session.grantId !== String(grantId)) continue;
+    if (sessionId !== void 0 && id !== sessionId) continue;
+    finish(session, "stopped", "Authorization or connection closed");
+    clearTimeout(session.expiry);
+    state2.sessions.delete(id);
+  }
+}
+
+// src/agent/documents.mjs
+import fs5 from "node:fs/promises";
+import path6 from "node:path";
+import { constants as constants4 } from "node:fs";
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { deflateSync } from "node:zlib";
+import { unzipSync, zipSync, strToU8, strFromU8 } from "fflate";
+import { XMLParser, XMLValidator } from "fast-xml-parser";
+import XLSX from "xlsx";
+import { PDFDocument, degrees } from "pdf-lib";
+import fontkit from "@pdf-lib/fontkit";
+
+// src/config.mjs
+import path5 from "node:path";
+import { fileURLToPath } from "node:url";
+var projectDir = path5.resolve(path5.dirname(fileURLToPath(import.meta.url)), "..");
+
+// src/agent/documents.mjs
+var MAX_FILE2 = 20 * 1024 * 1024;
+var MAX_PART = 16 * 1024 * 1024;
+var MAX_EXPANDED = 64 * 1024 * 1024;
+var MAX_RESULT = 680 * 1024;
+var MAX_INPUT = 512 * 1024;
+var IMAGE_LIMIT = 480 * 1024;
+var XML = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@", trimValues: false, parseTagValue: false, processEntities: true });
+var ORDERED_XML = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@", preserveOrder: true, trimValues: false, parseTagValue: false, processEntities: true });
+function bounded(result) {
+  if (Buffer.byteLength(JSON.stringify(result)) > MAX_RESULT) throw new Error("Document result exceeds 680 KiB; use a smaller range or page length");
+  return result;
+}
+function integer3(value, fallback, min, max, name) {
+  if (value === void 0) return fallback;
+  if (!Number.isInteger(value) || value < min || value > max) throw new Error(`${name} must be an integer from ${min} to ${max}`);
+  return value;
+}
+function textInput(value, name = "content") {
+  if (typeof value !== "string" || Buffer.byteLength(value) > MAX_INPUT || /[\x00-\x08\x0B\x0C\x0E-\x1F]/.test(value)) throw new Error(`${name} must be text up to 512 KiB without invalid control characters`);
+  return value;
+}
+async function readBytes(file, limit = MAX_FILE2) {
+  const handle = await fs5.open(file, constants4.O_RDONLY | (constants4.O_NOFOLLOW || 0));
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size > limit) throw new Error(`Document must be a regular file no larger than ${Math.floor(limit / 1024)} KiB`);
+    const buffer = Buffer.alloc(stat.size + 1);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    if (bytesRead !== stat.size) throw new Error("Document changed while it was being read");
+    return buffer.subarray(0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+function writable(config) {
+  if (!config.allowWrite) throw new Error("File writes are disabled on this PC");
+}
+async function saveBytes(config, file, bytes, overwrite = false) {
+  writable(config);
+  if (bytes.length > MAX_FILE2) throw new Error("Generated document exceeds 20 MiB");
+  const previous = await fs5.lstat(file).catch((error) => {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  });
+  if (previous && (!previous.isFile() || previous.isSymbolicLink())) throw new Error("Destination must be a regular file");
+  if (previous && !overwrite) throw new Error("File already exists; set overwrite=true explicitly");
+  const temporary = path6.join(path6.dirname(file), `.cetrix-document-${randomUUID4()}.tmp`);
+  try {
+    await fs5.writeFile(temporary, bytes, { flag: "wx", mode: previous ? previous.mode & 511 : 384 });
+    if (overwrite) await fs5.rename(temporary, file);
+    else {
+      await fs5.link(temporary, file);
+      await fs5.unlink(temporary);
+    }
+  } finally {
+    await fs5.unlink(temporary).catch(() => {
+    });
+  }
+  return { written: true, bytes: bytes.length, format: path6.extname(file).slice(1) };
+}
+function validateXml(xml) {
+  if (/<!DOCTYPE|<!ENTITY/i.test(xml)) throw new Error("XML document types and entity declarations are not allowed");
+  const result = XMLValidator.validate(xml);
+  if (result !== true) throw new Error(`Malformed document XML: ${result.err.msg}`);
+  return xml;
+}
+function escapeXml(value) {
+  return String(value).replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&apos;" })[char]);
+}
+function prettyXml(xml) {
+  const textElements = [];
+  const protectedXml = xml.replace(/<(?:\w+:)?t\b[^>]*>[\s\S]*?<\/(?:\w+:)?t>/g, (value) => `
${textElements.push(value) - 1}`);
+  return protectedXml.replace(/>\s*</g, ">\n<").replace(/\u0001(\d+)\u0002/g, (_, index) => textElements[Number(index)]);
+}
+var CRC_TABLE = Array.from({ length: 256 }, (_, index) => {
+  let crc = index;
+  for (let bit = 0; bit < 8; bit++) crc = crc >>> 1 ^ 3988292384 & -(crc & 1);
+  return crc >>> 0;
+});
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (const byte of bytes) crc = crc >>> 8 ^ CRC_TABLE[(crc ^ byte) & 255];
+  return (crc ^ 4294967295) >>> 0;
+}
+function archive(bytes) {
+  let eocd = -1;
+  for (let i = bytes.length - 22; i >= Math.max(0, bytes.length - 65557); i--) {
+    if (bytes.readUInt32LE(i) === 101010256 && i + 22 + bytes.readUInt16LE(i + 20) === bytes.length) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0) throw new Error("Malformed ZIP document");
+  const count = bytes.readUInt16LE(eocd + 10), directorySize = bytes.readUInt32LE(eocd + 12), start2 = bytes.readUInt32LE(eocd + 16);
+  if (count > 2e3 || count === 65535 || start2 + directorySize !== eocd || bytes.readUInt16LE(eocd + 4) || bytes.readUInt16LE(eocd + 6)) throw new Error("ZIP document has unsupported or excessive entries");
+  const expected = /* @__PURE__ */ new Map();
+  let cursor = start2, expanded = 0;
+  for (let i = 0; i < count; i++) {
+    if (cursor + 46 > eocd || bytes.readUInt32LE(cursor) !== 33639248) throw new Error("Malformed ZIP central directory");
+    const flags = bytes.readUInt16LE(cursor + 8), compression = bytes.readUInt16LE(cursor + 10), crc = bytes.readUInt32LE(cursor + 16);
+    const compressed = bytes.readUInt32LE(cursor + 20), size = bytes.readUInt32LE(cursor + 24);
+    const nameLength = bytes.readUInt16LE(cursor + 28), extraLength = bytes.readUInt16LE(cursor + 30), commentLength = bytes.readUInt16LE(cursor + 32), local = bytes.readUInt32LE(cursor + 42);
+    const end = cursor + 46 + nameLength + extraLength + commentLength;
+    if (end > eocd || local + 30 > start2 || bytes.readUInt32LE(local) !== 67324752) throw new Error("Malformed ZIP entry");
+    const name = bytes.subarray(cursor + 46, cursor + 46 + nameLength).toString("utf8");
+    expanded += size;
+    if (flags & 1 || ![0, 8].includes(compression) || size > MAX_PART || expanded > MAX_EXPANDED || size > 1024 * 1024 && size > Math.max(1, compressed) * 300) throw new Error("ZIP document exceeds decompression limits");
+    if (!name || name.includes("\0") || name.includes("\\") || name.startsWith("/") || name.split("/").includes("..") || expected.has(name) || name === "__proto__" || name === "constructor") throw new Error("Unsafe or duplicate ZIP entry");
+    const payloadStart = local + 30 + bytes.readUInt16LE(local + 26) + bytes.readUInt16LE(local + 28);
+    if (payloadStart + compressed > start2) throw new Error("Malformed ZIP entry data");
+    expected.set(name, { size, crc });
+    cursor = end;
+  }
+  if (cursor !== eocd) throw new Error("Malformed ZIP directory size");
+  const entries = unzipSync(bytes);
+  if (Object.keys(entries).length !== expected.size) throw new Error("ZIP entry count mismatch");
+  for (const [name, item] of expected) {
+    if (!entries[name] || entries[name].length !== item.size || crc32(entries[name]) !== item.crc) throw new Error("ZIP document integrity check failed");
+  }
+  return entries;
+}
+function xmlPart(entries, name) {
+  if (!entries[name]) throw new Error(`Document is missing ${name}`);
+  return validateXml(strFromU8(entries[name]));
+}
+function paginated(items, args, defaultLength = 1e3) {
+  const offset = integer3(args.offset, 0, -1e6, 1e6, "offset");
+  const length = integer3(args.length, defaultLength, 1, 1e4, "length");
+  const start2 = offset < 0 ? Math.max(0, items.length + offset) : offset;
+  const end = offset < 0 ? items.length : Math.min(items.length, start2 + length);
+  return { items: items.slice(start2, end), offset: start2, total: items.length, truncated: end < items.length };
+}
+function docxText(nodes, textNode = false) {
+  let output = "";
+  for (const node of nodes || []) for (const [key, value] of Object.entries(node)) {
+    if (key === "#text" && textNode) output += value;
+    else if (key === "w:tab") output += "	";
+    else if (key === "w:br" || key === "w:cr") output += "\n";
+    else if (key !== ":@" && Array.isArray(value)) output += docxText(value, key === "w:t");
+  }
+  return output;
+}
+function docxNodes(nodes, name) {
+  const found = [];
+  for (const node of nodes || []) for (const [key, value] of Object.entries(node)) {
+    if (key === name) found.push(node);
+    else if (key !== ":@" && Array.isArray(value)) found.push(...docxNodes(value, name));
+  }
+  return found;
+}
+function readDocx(bytes, args) {
+  const entries = archive(bytes), xml = xmlPart(entries, "word/document.xml");
+  if (args.offset) {
+    const data2 = paginated(prettyXml(xml).split("\n"), args);
+    return bounded({ format: "docx-xml", part: "word/document.xml", content: data2.items.join("\n"), offset: data2.offset, totalLines: data2.total, truncated: data2.truncated });
+  }
+  const document = ORDERED_XML.parse(xml).find((node) => node["w:document"])?.["w:document"];
+  const bodyNodes = document?.find((node) => node["w:body"])?.["w:body"];
+  if (!bodyNodes) throw new Error("DOCX has no supported WordprocessingML body");
+  const body = bodyNodes.filter((node) => Object.keys(node).some((key) => key !== "#text" && key !== ":@"));
+  const outline = body.flatMap((node, index) => {
+    const kind = Object.keys(node).find((key) => key !== ":@");
+    if (!["w:p", "w:tbl"].includes(kind)) return [];
+    const rows = kind === "w:tbl" ? docxNodes(node[kind], "w:tr").map((row) => docxNodes(row["w:tr"], "w:tc").map((cell) => docxNodes(cell["w:tc"], "w:p").map((paragraph) => docxText(paragraph["w:p"])).join("\n"))) : void 0;
+    const text = rows ? rows.map((row) => row.join("	")).join("\n") : docxText(node[kind]);
+    const serialized = JSON.stringify(node);
+    const style = docxNodes(node[kind], "w:pStyle")[0]?.[":@"]?.["@w:val"];
+    const images = [...serialized.matchAll(/"@r:embed":"([^"]+)"/g)].map((item) => item[1]);
+    return text || images.length ? [{ index, type: kind === "w:tbl" ? "table" : "paragraph", text, ...rows ? { rows } : {}, ...style ? { style } : {}, ...images.length ? { images } : {} }] : [];
+  });
+  const data = paginated(outline, { length: args.length }, 1e3);
+  return bounded({ format: "docx", outline: data.items, totalElements: body.length, truncated: data.truncated });
+}
+var DOCX_STYLES = `<?xml version="1.0" encoding="UTF-8"?><w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style>${[1, 2, 3, 4, 5, 6].map((level) => `<w:style w:type="paragraph" w:styleId="Heading${level}"><w:name w:val="heading ${level}"/><w:basedOn w:val="Normal"/><w:pPr><w:outlineLvl w:val="${level - 1}"/></w:pPr><w:rPr><w:b/><w:sz w:val="${36 - level * 2}"/></w:rPr></w:style>`).join("")}</w:styles>`;
+function newDocx(content) {
+  const paragraphs = textInput(content).split(/\r?\n/).map((line) => {
+    const heading = /^(#{1,6})\s+(.*)$/.exec(line);
+    return `<w:p>${heading ? `<w:pPr><w:pStyle w:val="Heading${heading[1].length}"/></w:pPr>` : ""}<w:r><w:t xml:space="preserve">${escapeXml(heading ? heading[2] : line)}</w:t></w:r></w:p>`;
+  }).join("");
+  return zipSync({
+    "[Content_Types].xml": strToU8('<?xml version="1.0"?><Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/><Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/></Types>'),
+    "_rels/.rels": strToU8('<?xml version="1.0"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>'),
+    "word/_rels/document.xml.rels": strToU8('<?xml version="1.0"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rIdStyles" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/></Relationships>'),
+    "word/document.xml": strToU8(`<?xml version="1.0" encoding="UTF-8"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>${paragraphs}<w:sectPr><w:pgSz w:w="11906" w:h="16838"/><w:pgMar w:top="1440" w:right="1440" w:bottom="1440" w:left="1440"/></w:sectPr></w:body></w:document>`),
+    "word/styles.xml": strToU8(DOCX_STYLES)
+  }, { level: 6 });
+}
+async function editDocx(config, file, args) {
+  const oldText = textInput(args.old_string, "old_string"), newText = textInput(args.new_string, "new_string");
+  if (!oldText) throw new Error("old_string cannot be empty");
+  const expected = integer3(args.expected_replacements, 1, 1, 1e4, "expected_replacements");
+  const entries = archive(await readBytes(file));
+  const names = ["word/document.xml", ...Object.keys(entries).filter((name) => /^word\/(header|footer)\d+\.xml$/.test(name))];
+  const sources = names.map((name) => [name, prettyXml(xmlPart(entries, name))]);
+  const count = sources.reduce((sum, [, xml]) => sum + xml.split(oldText).length - 1, 0);
+  if (count !== expected) throw new Error(`Expected ${expected} exact replacements, found ${count}; original document was not changed`);
+  for (const [name, source] of sources) if (source.includes(oldText)) {
+    const updated = validateXml(source.split(oldText).join(newText)), parsed = XML.parse(updated);
+    if (name === "word/document.xml" ? !parsed["w:document"]?.["w:body"] : name.includes("header") ? !parsed["w:hdr"] : !parsed["w:ftr"]) throw new Error("DOCX edit removed its required document structure");
+    entries[name] = strToU8(updated);
+  }
+  const result = await saveBytes(config, file, zipSync(entries, { level: 6 }), true);
+  return { ...result, replacements: count };
+}
+function spreadsheet(bytes, extension) {
+  if (extension !== ".xls") archive(bytes);
+  else if (!bytes.subarray(0, 8).equals(Buffer.from("d0cf11e0a1b11ae1", "hex"))) throw new Error("Expected a binary XLS workbook");
+  return XLSX.read(bytes, { type: "buffer", cellFormula: true, cellDates: true, cellNF: true, bookVBA: false, WTF: false });
+}
+function chooseSheet(book, value) {
+  const chosen = value === void 0 ? book.SheetNames[0] : book.SheetNames.includes(String(value)) ? String(value) : book.SheetNames[Number(value)];
+  if (!chosen || !book.Sheets[chosen]) throw new Error("Worksheet does not exist");
+  return chosen;
+}
+function decodeRange(value) {
+  if (typeof value !== "string" || !/^[A-Z]{1,3}[1-9]\d{0,6}:[A-Z]{1,3}[1-9]\d{0,6}$/i.test(value)) throw new Error("range must use A1:D100 notation");
+  const range = XLSX.utils.decode_range(value.toUpperCase());
+  if (range.s.r > range.e.r || range.s.c > range.e.c || range.e.r >= 1048576 || range.e.c >= 16384) throw new Error("Invalid spreadsheet range");
+  return range;
+}
+function readSpreadsheet(bytes, extension, args) {
+  const book = spreadsheet(bytes, extension);
+  const sheets = book.SheetNames.map((name2) => {
+    const reference = book.Sheets[name2]["!ref"];
+    const range2 = reference ? XLSX.utils.decode_range(reference) : null;
+    return { name: name2, range: reference || null, rowCount: range2 ? range2.e.r + 1 : 0, colCount: range2 ? range2.e.c + 1 : 0 };
+  });
+  if (args.metadataOnly === true) return bounded({ format: extension.slice(1), sheets });
+  const name = chooseSheet(book, args.sheet), sheet = book.Sheets[name];
+  const full = sheet["!ref"] ? XLSX.utils.decode_range(sheet["!ref"]) : { s: { r: 0, c: 0 }, e: { r: -1, c: -1 } };
+  let range;
+  if (args.range) range = decodeRange(args.range);
+  else {
+    const offset = integer3(args.offset, 0, -1048576, 1048575, "offset"), length = integer3(args.length, 100, 1, 1e4, "length");
+    const start2 = offset < 0 ? Math.max(0, full.e.r + 1 + offset) : offset;
+    range = { s: { r: start2, c: full.s.c }, e: { r: Math.min(full.e.r, offset < 0 ? full.e.r : start2 + length - 1), c: full.e.c } };
+  }
+  if ((range.e.r - range.s.r + 1) * (range.e.c - range.s.c + 1) > 1e4) throw new Error("Read at most 10000 cells per call using range");
+  const rows = [], formulas = {};
+  for (let r = range.s.r; r <= range.e.r; r++) {
+    const row = [];
+    for (let c = range.s.c; c <= range.e.c; c++) {
+      const address = XLSX.utils.encode_cell({ r, c }), cell = sheet[address];
+      row.push(cell?.v instanceof Date ? cell.v.toISOString() : cell?.v ?? null);
+      if (cell?.f) formulas[address] = cell.f;
+    }
+    rows.push(row);
+  }
+  return bounded({ format: extension.slice(1), sheet: name, range: range.e.r >= range.s.r ? XLSX.utils.encode_range(range) : null, rows, formulas, sheets, truncated: range.e.r < full.e.r, formulasCalculated: false });
+}
+function parseCells(content) {
+  const data = typeof content === "string" ? JSON.parse(textInput(content)) : content;
+  if (Buffer.byteLength(JSON.stringify(data) || "") > MAX_INPUT) throw new Error("Spreadsheet input exceeds 512 KiB");
+  return data;
+}
+function cellValue(value) {
+  if (value === null) return null;
+  if (typeof value === "string") return { t: "s", v: textInput(value) };
+  if (typeof value === "number" && Number.isFinite(value)) return { t: "n", v: value };
+  if (typeof value === "boolean") return { t: "b", v: value };
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    if (value.type === "date" && typeof value.value === "string") {
+      const date = new Date(value.value);
+      if (!Number.isFinite(+date)) throw new Error("Invalid date cell");
+      return { t: "d", v: date, z: "yyyy-mm-dd hh:mm:ss" };
+    }
+    if (typeof value.formula === "string") {
+      const formula = textInput(value.formula, "formula").replace(/^=/, "");
+      if (!formula || formula.length > 8192) throw new Error("Invalid cell formula");
+      const result = value.value === void 0 ? { t: "n", v: 0 } : cellValue(value.value);
+      if (!result || !["s", "n", "b"].includes(result.t)) throw new Error("Formula cached value must be string, number or boolean");
+      return { ...result, f: formula };
+    }
+  }
+  throw new Error('Cells must contain strings, numbers, booleans, null, {formula,value}, or {type:"date",value:ISO}');
+}
+function validateRows(rows) {
+  if (!Array.isArray(rows) || !rows.length || rows.length > 1e4 || rows.some((row) => !Array.isArray(row))) throw new Error("Spreadsheet content must be a nonempty JSON two-dimensional array");
+  const width = Math.max(...rows.map((row) => row.length));
+  if (!width || width > 1e3 || rows.length * width > 1e4) throw new Error("Write at most 10000 cells per call");
+  return rows.map((row) => row.map(cellValue));
+}
+function newWorkbook(content, args, extension) {
+  const data = parseCells(content), book = XLSX.utils.book_new();
+  const sheets = Array.isArray(data) ? { [args.sheet || "Sheet1"]: data } : data;
+  if (!sheets || typeof sheets !== "object" || Object.keys(sheets).length < 1 || Object.keys(sheets).length > 100) throw new Error("Expected a cell array or sheet-name map");
+  for (const [name, values] of Object.entries(sheets)) {
+    if (!name || name.length > 31 || /[\\/?*\[\]:]/.test(name)) throw new Error("Invalid worksheet name");
+    const rows = validateRows(values), sheet = {};
+    rows.forEach((row, r) => row.forEach((cell, c) => {
+      if (cell) sheet[XLSX.utils.encode_cell({ r, c })] = cell;
+    }));
+    sheet["!ref"] = XLSX.utils.encode_range({ s: { r: 0, c: 0 }, e: { r: rows.length - 1, c: Math.max(...rows.map((row) => row.length)) - 1 } });
+    XLSX.utils.book_append_sheet(book, sheet, name);
+  }
+  return XLSX.write(book, { type: "buffer", bookType: extension === ".xls" ? "biff8" : extension.slice(1), compression: true, cellStyles: true });
+}
+function cellXml(value, address, old, prefix) {
+  if (!value) return "";
+  let attributes = old?.match(/^<[^\s>]+\s([^>]*?)\/?>(?:.|\n)*$/)?.[1] || "";
+  attributes = attributes.replace(/\b(?:r|t)\s*=\s*(?:"[^"]*"|'[^']*')/g, "").trim();
+  const start2 = `<${prefix}c r="${address}"${attributes ? ` ${attributes}` : ""}`;
+  if (value.f) return `${start2} t="${value.t === "s" ? "str" : value.t}"><${prefix}f>${escapeXml(value.f)}</${prefix}f><${prefix}v>${escapeXml(value.t === "b" ? +value.v : value.v)}</${prefix}v></${prefix}c>`;
+  if (value.t === "s") return `${start2} t="inlineStr"><${prefix}is><${prefix}t xml:space="preserve">${escapeXml(value.v)}</${prefix}t></${prefix}is></${prefix}c>`;
+  if (value.t === "d") {
+    return `${start2} t="d"><${prefix}v>${value.v.toISOString()}</${prefix}v></${prefix}c>`;
+  }
+  return `${start2} t="${value.t}"><${prefix}v>${value.t === "b" ? +value.v : value.v}</${prefix}v></${prefix}c>`;
+}
+async function updateSpreadsheet(config, file, args, content) {
+  if (path6.extname(file).toLowerCase() === ".xls") {
+    if (args.allowLossy !== true) throw new Error("Legacy XLS editing may discard formatting and unsupported features; use allowLossy=true explicitly or save as XLSX first");
+    const book2 = spreadsheet(await readBytes(file), ".xls"), name2 = chooseSheet(book2, args.sheet), sheet = book2.Sheets[name2], rows2 = validateRows(parseCells(content));
+    const range2 = args.range ? decodeRange(args.range) : { s: { r: args.mode === "append" ? XLSX.utils.decode_range(sheet["!ref"] || "A1:A1").e.r + 1 : 0, c: 0 } };
+    const width2 = Math.max(...rows2.map((row) => row.length));
+    if (range2.e && (range2.e.r - range2.s.r + 1 !== rows2.length || range2.e.c - range2.s.c + 1 !== width2)) throw new Error("JSON data dimensions must match the target range");
+    if (range2.s.r + rows2.length > 65536 || range2.s.c + width2 > 256) throw new Error("Write exceeds legacy XLS boundaries");
+    rows2.forEach((row, r) => row.forEach((cell, c) => {
+      const address = XLSX.utils.encode_cell({ r: range2.s.r + r, c: range2.s.c + c });
+      if (cell) sheet[address] = cell;
+      else delete sheet[address];
+    }));
+    const previous = XLSX.utils.decode_range(sheet["!ref"] || "A1:A1");
+    sheet["!ref"] = XLSX.utils.encode_range({ s: { r: Math.min(previous.s.r, range2.s.r), c: Math.min(previous.s.c, range2.s.c) }, e: { r: Math.max(previous.e.r, range2.s.r + rows2.length - 1), c: Math.max(previous.e.c, range2.s.c + width2 - 1) } });
+    return { ...await saveBytes(config, file, XLSX.write(book2, { type: "buffer", bookType: "biff8", cellStyles: true }), true), sheet: name2, warning: "Legacy XLS was rebuilt; unsupported formatting, drawings, macros and workbook features may be lost.", formulasCalculated: false };
+  }
+  const bytes = await readBytes(file), entries = archive(bytes), book = spreadsheet(bytes, path6.extname(file).toLowerCase());
+  const name = chooseSheet(book, args.sheet), rows = validateRows(parseCells(content));
+  const sheetIndex = book.SheetNames.indexOf(name);
+  const workbookXml = xmlPart(entries, "xl/workbook.xml"), workbook = XML.parse(workbookXml);
+  const wbRoot = workbook.workbook;
+  const sheetNodes = [].concat(wbRoot?.sheets?.sheet || []), id = sheetNodes[sheetIndex]?.["@r:id"];
+  const relationships = [].concat(XML.parse(xmlPart(entries, "xl/_rels/workbook.xml.rels")).Relationships?.Relationship || []);
+  const relation = relationships.find((item) => item["@Id"] === id);
+  if (!relation || relation["@TargetMode"] === "External") throw new Error("Worksheet relationship is invalid");
+  const entryName = path6.posix.normalize(relation["@Target"].startsWith("/") ? relation["@Target"].slice(1) : `xl/${relation["@Target"]}`);
+  if (!entryName.startsWith("xl/worksheets/")) throw new Error("Worksheet relationship is outside the workbook");
+  let xml = xmlPart(entries, entryName);
+  const prefix = /^\s*(?:<\?xml[^>]*>\s*)?<((?:\w+:)?)worksheet\b/.exec(xml)?.[1] || "";
+  const range = args.range ? decodeRange(args.range) : { s: { r: args.mode === "append" ? XLSX.utils.decode_range(book.Sheets[name]["!ref"] || "A1:A1").e.r + 1 : 0, c: 0 } };
+  const height = rows.length, width = Math.max(...rows.map((row) => row.length));
+  if (range.e && (range.e.r - range.s.r + 1 !== height || range.e.c - range.s.c + 1 !== width)) throw new Error("JSON data dimensions must match the target range");
+  if (range.s.r + height > 1048576 || range.s.c + width > 16384) throw new Error("Write exceeds worksheet boundaries");
+  const section = new RegExp(`<${prefix}sheetData(?:\\s[^>]*)?(?:\\/>|>([\\s\\S]*?)<\\/${prefix}sheetData>)`).exec(xml);
+  if (!section) throw new Error("Worksheet sheetData was not found");
+  const existingRows = /* @__PURE__ */ new Map();
+  for (const match of (section[1] || "").matchAll(new RegExp(`<${prefix}row\\b[^>]*(?:\\/>|>[\\s\\S]*?<\\/${prefix}row>)`, "g"))) {
+    const r = /\br="(\d+)"/.exec(match[0]);
+    if (!r) throw new Error("Worksheet row has no index");
+    existingRows.set(Number(r[1]), match[0]);
+  }
+  rows.forEach((values, rowIndex) => {
+    const r = range.s.r + rowIndex + 1, previous = existingRows.get(r), cells = /* @__PURE__ */ new Map();
+    if (previous) for (const match of previous.matchAll(new RegExp(`<${prefix}c\\b[^>]*(?:\\/>|>[\\s\\S]*?<\\/${prefix}c>)`, "g"))) {
+      const address = /\br="([A-Z]+\d+)"/.exec(match[0])?.[1];
+      if (!address) throw new Error("Worksheet cell has no address");
+      cells.set(address, match[0]);
+    }
+    values.forEach((cell, colIndex) => {
+      const address = XLSX.utils.encode_cell({ r: r - 1, c: range.s.c + colIndex });
+      cells.set(address, cellXml(cell, address, cells.get(address), prefix));
+    });
+    const start2 = previous ? previous.match(/^[^>]+>/)[0].replace(/\/>$/, ">") : `<${prefix}row r="${r}">`;
+    const body = [...cells.entries()].sort(([a], [b]) => XLSX.utils.decode_cell(a).c - XLSX.utils.decode_cell(b).c).map(([, value]) => value).join("");
+    const extra = previous ? previous.replace(/^[^>]+>/, "").replace(new RegExp(`<\\/${prefix}row>$`), "").replace(new RegExp(`<${prefix}c\\b[^>]*(?:\\/>|>[\\s\\S]*?<\\/${prefix}c>)`, "g"), "") : "";
+    existingRows.set(r, `${start2}${body}${extra}</${prefix}row>`);
+  });
+  const sheetData = `<${prefix}sheetData>${[...existingRows.entries()].sort(([a], [b]) => a - b).map(([, value]) => value).join("")}</${prefix}sheetData>`;
+  xml = xml.replace(section[0], sheetData);
+  const oldRange = XLSX.utils.decode_range(book.Sheets[name]["!ref"] || "A1:A1");
+  const bounds = XLSX.utils.encode_range({ s: { r: Math.min(oldRange.s.r, range.s.r), c: Math.min(oldRange.s.c, range.s.c) }, e: { r: Math.max(oldRange.e.r, range.s.r + height - 1), c: Math.max(oldRange.e.c, range.s.c + width - 1) } });
+  xml = xml.replace(new RegExp(`<${prefix}dimension\\b[^>]*\\/>`), `<${prefix}dimension ref="${bounds}"/>`);
+  entries[entryName] = strToU8(validateXml(xml));
+  return { ...await saveBytes(config, file, zipSync(entries, { level: 6 }), true), sheet: name, range: XLSX.utils.encode_range({ s: range.s, e: { r: range.s.r + height - 1, c: range.s.c + width - 1 } }), formulasCalculated: false };
+}
+function pngChunk(type, bytes) {
+  const chunk = Buffer.alloc(bytes.length + 12);
+  chunk.writeUInt32BE(bytes.length);
+  chunk.write(type, 4, "ascii");
+  bytes.copy(chunk, 8);
+  chunk.writeUInt32BE(crc32(chunk.subarray(4, 8 + bytes.length)), 8 + bytes.length);
+  return chunk;
+}
+function extractedPng(image) {
+  if (!image || !Number.isInteger(image.width) || !Number.isInteger(image.height) || image.width < 1 || image.height < 1) throw new Error("Decoded image has invalid dimensions");
+  if (image.width * image.height > 2e6) throw new Error("Image exceeds 2 million pixels");
+  const color = image.kind === 1 ? 0 : image.kind === 2 ? 2 : image.kind === 3 ? 6 : null;
+  if (color === null || !image.data) throw new Error("Unsupported decoded image format");
+  const depth = image.kind === 1 ? 1 : 8, rowBytes = image.kind === 1 ? Math.ceil(image.width / 8) : image.width * (image.kind === 2 ? 3 : 4);
+  if (image.data.length !== rowBytes * image.height) throw new Error("Decoded image length mismatch");
+  const header = Buffer.alloc(13);
+  header.writeUInt32BE(image.width);
+  header.writeUInt32BE(image.height, 4);
+  header[8] = depth;
+  header[9] = color;
+  const rows = Buffer.alloc((rowBytes + 1) * image.height), source = Buffer.from(image.data.buffer, image.data.byteOffset, image.data.byteLength);
+  for (let y = 0; y < image.height; y++) source.copy(rows, y * (rowBytes + 1) + 1, y * rowBytes, (y + 1) * rowBytes);
+  return Buffer.concat([Buffer.from("89504e470d0a1a0a", "hex"), pngChunk("IHDR", header), pngChunk("IDAT", deflateSync(rows)), pngChunk("IEND", Buffer.alloc(0))]);
+}
+async function pdfImageObject(page2, id) {
+  const objects = String(id).startsWith("g_") ? page2.commonObjs : page2.objs;
+  if (objects.has(id)) return objects.get(id);
+  let timer;
+  try {
+    return await Promise.race([new Promise((resolve) => objects.get(id, resolve)), new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error("Image decoding timed out")), 2e3);
+    })]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function readPdf(bytes, args) {
+  const { getDocument, OPS } = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  const task = getDocument({ data: new Uint8Array(bytes), isEvalSupported: false, useSystemFonts: false, disableFontFace: true, isOffscreenCanvasSupported: false, isImageDecoderSupported: false, maxImageSize: 16e6, verbosity: 0 });
+  try {
+    const document = await task.promise;
+    if (document.numPages > 2e3) throw new Error("PDF exceeds 2000 pages");
+    if (args.metadataOnly === true) return { format: "pdf", totalPages: document.numPages };
+    const offset = integer3(args.offset, 0, -2e3, 2e3, "offset"), length = integer3(args.length, 10, 1, 30, "length");
+    const start2 = offset < 0 ? Math.max(0, document.numPages + offset) : offset;
+    const end = Math.min(document.numPages, start2 + length), pages = [], candidates = [], images = [];
+    let omittedImages = 0, attemptedImages = 0;
+    for (let index = start2; index < end; index++) {
+      const page2 = await document.getPage(index + 1), content = await page2.getTextContent();
+      const text2 = content.items.filter((item) => typeof item.str === "string").map((item) => item.str + (item.hasEOL ? "\n" : " ")).join("").trim();
+      pages.push({ page: index + 1, text: text2, width: page2.view[2] - page2.view[0], height: page2.view[3] - page2.view[1] });
+      bounded({ pages });
+      if (args.includeImages !== false) {
+        try {
+          const operators = await page2.getOperatorList(), seen = /* @__PURE__ */ new Set();
+          for (let i = 0; i < operators.fnArray.length; i++) {
+            const operation = operators.fnArray[i], values = operators.argsArray[i];
+            if (![OPS.paintImageXObject, OPS.paintImageXObjectRepeat, OPS.paintInlineImageXObject, OPS.paintInlineImageXObjectGroup].includes(operation)) continue;
+            const id = typeof values[0] === "string" ? values[0] : `inline-${i}`;
+            if (seen.has(id)) continue;
+            seen.add(id);
+            if (images.length >= 200) {
+              omittedImages++;
+              continue;
+            }
+            const record = { page: index + 1, index: seen.size, status: "skipped" };
+            images.push(record);
+            if (candidates.length >= 10) {
+              record.reason = "Maximum 10 embedded images per read";
+              continue;
+            }
+            if (attemptedImages++ >= 50) {
+              record.reason = "Maximum 50 image decoding attempts per read";
+              continue;
+            }
+            try {
+              const decoded = typeof values[0] === "string" ? await pdfImageObject(page2, values[0]) : values[0];
+              const png = extractedPng(decoded);
+              if (png.length > IMAGE_LIMIT) throw new Error("Encoded image exceeds 480 KiB");
+              candidates.push({ record, block: { type: "image", mimeType: "image/png", data: png.toString("base64") } });
+              record.width = decoded.width;
+              record.height = decoded.height;
+              record.reason = "Response budget";
+            } catch (error) {
+              record.reason = error.message;
+            }
+          }
+        } catch (error) {
+          images.push({ page: index + 1, status: "skipped", reason: `Image extraction failed: ${error.message}` });
+        }
+      }
+      page2.cleanup();
+    }
+    const metadata = { format: "pdf", totalPages: document.numPages, pages, offset: start2, truncated: end < document.numPages, images, omittedImages, note: args.includeImages === false ? "Scanned pages require OCR; image extraction disabled." : "Scanned pages require OCR. Embedded raster images are extracted where supported; vector drawings and image masks are not standalone images. Images above 16 million pixels are omitted by the decoder." };
+    const text = () => pages.map((page2) => `## Page ${page2.page}
+
+${page2.text}`).join("\n\n") + `
+
+${metadata.note}
+Image extraction: ${JSON.stringify(images)}${omittedImages ? `
+${omittedImages} additional images omitted from extraction listing.` : ""}`;
+    const result = { ...metadata, content: [{ type: "text", text: text() }] };
+    bounded(result);
+    for (const { record, block } of candidates) {
+      record.status = "included";
+      delete record.reason;
+      result.content[0].text = text();
+      result.content.push(block);
+      if (Buffer.byteLength(JSON.stringify(result)) > MAX_RESULT - 2048) {
+        result.content.pop();
+        record.status = "skipped";
+        record.reason = "Response budget";
+      }
+    }
+    result.content[0].text = text();
+    return bounded(result);
+  } finally {
+    await task.destroy();
+  }
+}
+function imageResult(bytes, extension) {
+  const mimeType = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif", ".webp": "image/webp" }[extension];
+  const valid = extension === ".png" ? bytes.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex")) : [".jpg", ".jpeg"].includes(extension) ? bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255 : extension === ".gif" ? /^GIF8[79]a/.test(bytes.toString("ascii", 0, 6)) : bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP";
+  if (!valid) throw new Error("Image format does not match its extension");
+  return bounded({ format: "image", content: [{ type: "image", mimeType, data: bytes.toString("base64") }] });
+}
+async function readDocument(config, file, args = {}) {
+  const extension = path6.extname(file).toLowerCase();
+  const bytes = await readBytes(file, [".png", ".jpg", ".jpeg", ".gif", ".webp"].includes(extension) ? IMAGE_LIMIT : MAX_FILE2);
+  if (extension === ".docx") return readDocx(bytes, args);
+  if ([".xlsx", ".xls", ".xlsm"].includes(extension)) return readSpreadsheet(bytes, extension, args);
+  if (extension === ".pdf") return readPdf(bytes, args);
+  if ([".png", ".jpg", ".jpeg", ".gif", ".webp"].includes(extension)) return imageResult(bytes, extension);
+  throw new Error("Unsupported document format");
+}
+async function writeDocument(config, file, args = {}) {
+  writable(config);
+  const extension = path6.extname(file).toLowerCase();
+  if (extension === ".docx") {
+    if (args.mode === "append" || await fs5.stat(file).then(() => true, (error) => {
+      if (error.code === "ENOENT") return false;
+      throw error;
+    })) throw new Error("Use edit_block to modify an existing DOCX without losing its formatting");
+    return saveBytes(config, file, newDocx(args.content), false);
+  }
+  if ([".xlsx", ".xls", ".xlsm"].includes(extension)) {
+    if (args.range || args.mode === "append") return updateSpreadsheet(config, file, args, args.content);
+    return saveBytes(config, file, newWorkbook(args.content, args, extension), args.overwrite === true || args.mode === "rewrite");
+  }
+  if (extension === ".pdf") throw new Error("Use write_pdf to create or modify PDF files");
+  throw new Error("Document writing supports DOCX and spreadsheet formats");
+}
+async function editDocument(config, file, args = {}) {
+  writable(config);
+  const extension = path6.extname(file).toLowerCase();
+  if (extension === ".docx") return editDocx(config, file, args);
+  if ([".xlsx", ".xls", ".xlsm"].includes(extension)) {
+    if (!args.range) throw new Error("Spreadsheet edits require sheet and range");
+    const current = readSpreadsheet(await readBytes(file), extension, args);
+    const expected = parseCells(args.old_string);
+    if (JSON.stringify(current.rows) !== JSON.stringify(expected)) throw new Error("Spreadsheet range no longer matches old_string; original document was not changed");
+    return updateSpreadsheet(config, file, args, args.new_string);
+  }
+  throw new Error("Use write_pdf for PDF changes; this format does not support edit_block");
+}
+async function safeRelative(config, requested2, options) {
+  const { safePath: safePath2 } = await Promise.resolve().then(() => (init_files(), files_exports));
+  return safePath2(config, requested2, options);
+}
+function number2(value, fallback, min, max, name) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) throw new Error(`${name} is outside the supported range`);
+  return value;
+}
+async function writePdf(config, args = {}) {
+  writable(config);
+  const target = await safeRelative(config, args.path || args.filePath, { write: true });
+  if (path6.extname(target).toLowerCase() !== ".pdf") throw new Error("PDF output path must end in .pdf");
+  const mode = args.mode || "create";
+  if (!["create", "modify"].includes(mode)) throw new Error("PDF mode must be create or modify");
+  const pdf = mode === "modify" ? await PDFDocument.load(await readBytes(target), { updateMetadata: false }) : await PDFDocument.create();
+  if (pdf.getPageCount() > 2e3) throw new Error("PDF exceeds 2000 pages");
+  pdf.registerFontkit(fontkit);
+  const fontPath = args.font_path ? await safeRelative(config, args.font_path) : path6.join(projectDir, "assets", "fonts", "NotoSans-Regular.ttf");
+  const font = await pdf.embedFont(await readBytes(fontPath, 10 * 1024 * 1024), { subset: true });
+  const draw = (page2, text, options = {}) => {
+    try {
+      page2.drawText(textInput(text, "text"), { font, size: 12, ...options });
+    } catch (error) {
+      if (/WinAnsi cannot encode/.test(error.message)) throw new Error("This text needs a Unicode font: supply font_path pointing to a TTF/OTF font in the approved folder");
+      throw error;
+    }
+  };
+  if (args.content !== void 0) {
+    if (mode !== "create") throw new Error("For PDF modifications use operations; content is for new documents");
+    const content = textInput(args.content), size = number2(args.font_size, 12, 5, 72, "font_size");
+    let page2 = pdf.addPage([595.28, 841.89]), y = 791.89;
+    for (const line of content.split(/\r?\n/)) {
+      const heading = /^(#{1,6})\s+(.*)$/.exec(line), text = heading ? heading[2] : line, currentSize = heading ? Math.max(size, 23 - heading[1].length * 2) : size;
+      const pieces = text.split(/(\s+)/);
+      let wrapped = "";
+      for (const piece of pieces) {
+        let measured;
+        try {
+          measured = font.widthOfTextAtSize(wrapped + piece, currentSize);
+        } catch {
+          throw new Error("This text needs a Unicode font: supply font_path pointing to a TTF/OTF font in the approved folder");
+        }
+        if (measured > 495 && wrapped) {
+          if (y < 50) {
+            page2 = pdf.addPage([595.28, 841.89]);
+            y = 791.89;
+          }
+          draw(page2, wrapped.trimEnd(), { x: 50, y, size: currentSize });
+          y -= currentSize * 1.4;
+          wrapped = piece.trimStart();
+        } else wrapped += piece;
+      }
+      if (y < 50) {
+        page2 = pdf.addPage([595.28, 841.89]);
+        y = 791.89;
+      }
+      draw(page2, wrapped, { x: 50, y, size: currentSize });
+      y -= currentSize * 1.5;
+      if (pdf.getPageCount() > 500) throw new Error("Generated PDF exceeds 500 pages");
+    }
+  }
+  const operations = args.operations || [];
+  if (!Array.isArray(operations) || operations.length > 200) throw new Error("Provide at most 200 PDF operations");
+  for (const operation of operations) {
+    if (!operation || typeof operation !== "object") throw new Error("Invalid PDF operation");
+    if (operation.type === "add_page") {
+      pdf.addPage([number2(operation.width, 595.28, 10, 1e4, "width"), number2(operation.height, 841.89, 10, 1e4, "height")]);
+      continue;
+    }
+    const index = integer3(operation.page, 1, 1, pdf.getPageCount(), "page") - 1, page2 = pdf.getPage(index);
+    if (operation.type === "remove_page") {
+      if (pdf.getPageCount() === 1) throw new Error("Cannot remove the last PDF page");
+      pdf.removePage(index);
+    } else if (operation.type === "rotate_page") {
+      const rotation = integer3(operation.rotation, 90, -360, 360, "rotation");
+      if (rotation % 90) throw new Error("Page rotation must be a multiple of 90");
+      page2.setRotation(degrees(rotation));
+    } else if (operation.type === "text") draw(page2, operation.text, { x: number2(operation.x, 50, -1e4, 1e4, "x"), y: number2(operation.y, page2.getHeight() - 50, -1e4, 1e4, "y"), size: number2(operation.size, 12, 1, 1e3, "size") });
+    else if (operation.type === "image") {
+      const imagePath = await safeRelative(config, operation.image_path), bytes = await readBytes(imagePath, 5 * 1024 * 1024);
+      const extension = path6.extname(imagePath).toLowerCase();
+      if (![".png", ".jpg", ".jpeg"].includes(extension)) throw new Error("PDF images must be PNG or JPEG");
+      const embedded = extension === ".png" ? await pdf.embedPng(bytes) : await pdf.embedJpg(bytes);
+      page2.drawImage(embedded, { x: number2(operation.x, 50, -1e4, 1e4, "x"), y: number2(operation.y, 50, -1e4, 1e4, "y"), width: number2(operation.width, embedded.width, 1, 1e4, "width"), height: number2(operation.height, embedded.height, 1, 1e4, "height") });
+    } else throw new Error(`Unsupported PDF operation: ${operation.type}`);
+  }
+  if (args.form_fields) {
+    if (typeof args.form_fields !== "object" || Array.isArray(args.form_fields) || Object.keys(args.form_fields).length > 200) throw new Error("Invalid PDF form fields");
+    const form = pdf.getForm();
+    for (const [name, value] of Object.entries(args.form_fields)) {
+      const field = form.getField(name);
+      if (typeof value === "boolean" && typeof field.check === "function") value ? field.check() : field.uncheck();
+      else if (typeof value === "string" && typeof field.setText === "function") field.setText(textInput(value));
+      else throw new Error(`Unsupported PDF form field: ${name}`);
+    }
+    form.updateFieldAppearances(font);
+  }
+  if (!pdf.getPageCount()) throw new Error("Provide content or add_page operations for a new PDF");
+  return { ...await saveBytes(config, target, await pdf.save(), mode === "modify" || args.overwrite === true), pages: pdf.getPageCount(), note: mode === "modify" ? "Text operations add content; they do not redact or remove existing text." : void 0 };
+}
+
+// src/tool-defs.mjs
+import { z } from "zod";
+var path7 = z.string().min(1).max(2048);
+var paths = { path: path7.optional(), file_path: path7.optional(), filePath: path7.optional() };
+var paging = { offset: z.number().int().min(-1e7).max(1e7).optional(), length: z.number().int().min(1).max(2e3).optional() };
+var wait = z.number().int().min(0).max(25e3).optional();
+var tool = (name, scope, description, shape = {}, readonly = true) => ({ name, scope, description, schema: z.object(shape).strict(), readonly });
+var TOOL_DEFS = [
+  tool("get_device", "device:read", "Get identity and online status of this authorized PC."),
+  tool("list_devices", "device:read", "List devices visible to this connection. Its OAuth grant is restricted to exactly one PC."),
+  tool("whoami", "device:read", "Get the signed-in CetriX account and current device grant, without credentials."),
+  tool("ping_device", "device:read", "Ping this PC through the agent and report round-trip latency."),
+  tool("shutdown_device", "terminal:execute", "Stop this PC agent after confirming the response. Does not shut down Windows. Start the agent locally to reconnect.", {}, false),
+  tool("get_config", "device:read", "Get safe agent configuration, system information and client history; private keys and environment secrets are never returned."),
+  tool("set_config_value", "terminal:execute", "Update agent preferences. Directory access can only be narrowed within the locally approved root; this cannot grant new write or shell permissions.", { key: z.enum(["blockedCommands", "defaultShell", "allowedDirectories", "fileReadLineLimit", "fileWriteLineLimit", "telemetryEnabled"]), value: z.union([z.string(), z.number(), z.boolean(), z.array(z.string().max(2048)).max(100)]) }, false),
+  tool("get_prompts", "device:read", "Get a CetriX starter prompt by ID (onb2_01 through onb2_05), or list the five prompts. Returned prompts do not execute automatically.", { action: z.enum(["list", "get_prompt"]).optional(), promptId: z.string().max(80).optional() }),
+  tool("get_recent_tool_calls", "device:read", "Get this OAuth connection's in-memory tool history. Content is bounded and never persisted in server audit logs.", { ...paging, includeContent: z.boolean().default(false) }),
+  tool("get_usage_stats", "device:read", "Get this connection's tool counts, errors and durations since the agent started."),
+  tool("give_feedback", "device:read", "Save feedback to this CetriX instance for its owner; no third-party survey or telemetry is contacted.", { message: z.string().min(1).max(4e3) }, false),
+  tool("list_directory", "files:read", "List entries recursively relative to the approved root. Depth and result limits bound large directories.", { ...paths, depth: z.number().int().min(1).max(8).optional() }),
+  tool("get_file_info", "files:read", "Get file or directory metadata, text line counts and spreadsheet sheet information.", paths),
+  tool("read_file", "files:read", "Read UTF-8 text by lines, spreadsheets by sheet/range, DOCX outline or XML, PDF pages, or an image. Paths stay inside this PC's approved root. isUrl supports bounded public HTTPS text.", { ...paths, ...paging, isUrl: z.boolean().optional(), includeImages: z.boolean().optional(), sheet: z.union([z.string().max(100), z.number().int().min(0)]).optional(), range: z.string().max(100).optional() }),
+  tool("read_multiple_files", "files:read", "Read up to 20 files; an error in one file does not stop the other reads. Response size is bounded.", { paths: z.array(path7).min(1).max(20), ...paging }),
+  tool("write_file", "files:write", "Create, overwrite explicitly, or append text; create DOCX or spreadsheet data. Requires local write permission. PDF uses write_pdf.", { ...paths, content: z.union([z.string().max(524288), z.array(z.unknown()), z.record(z.string(), z.unknown())]), overwrite: z.boolean().default(false), mode: z.enum(["rewrite", "append"]).optional(), sheet: z.string().max(100).optional(), range: z.string().max(100).optional(), allowLossy: z.boolean().optional() }, false),
+  tool("edit_block", "files:write", "Replace an exact text/XML block after checking occurrence count, or edit an Excel range. No partial edit is made on a mismatch.", { ...paths, old_string: z.string().max(524288).optional(), new_string: z.string().max(524288).optional(), expected_replacements: z.number().int().min(1).max(1e4).optional(), content: z.union([z.string().max(524288), z.array(z.unknown())]).optional(), sheet: z.string().max(100).optional(), range: z.string().max(100).optional(), allowLossy: z.boolean().optional() }, false),
+  tool("create_directory", "files:write", "Create a directory including missing parent directories, within the approved root.", paths, false),
+  tool("move_file", "files:write", "Move or rename a file/directory inside the approved root. Destination must not already exist.", { source: path7, destination: path7 }, false),
+  tool("write_pdf", "files:write", "Create or modify a PDF: text/images, pages, rotation and form fields. Vietnamese text is supported by the bundled font.", { ...paths, content: z.string().max(524288).optional(), mode: z.enum(["create", "modify"]).optional(), overwrite: z.boolean().optional(), font_path: path7.optional(), font_size: z.number().min(5).max(72).optional(), operations: z.array(z.object({ type: z.enum(["text", "image", "add_page", "remove_page", "rotate_page"]), page: z.number().int().min(1).optional(), text: z.string().max(1e5).optional(), x: z.number().optional(), y: z.number().optional(), size: z.number().min(1).max(200).optional(), image_path: path7.optional(), width: z.number().positive().optional(), height: z.number().positive().optional(), rotation: z.number().optional() }).strict()).max(200).optional(), form_fields: z.record(z.string(), z.union([z.string(), z.boolean()])).optional() }, false),
+  tool("start_search", "files:read", "Start a bounded background search for filenames or text contents. Poll get_more_search_results with the returned sessionId.", { path: path7.default("."), pattern: z.string().min(1).max(500), searchType: z.enum(["files", "content"]).default("files"), literalSearch: z.boolean().optional(), filePattern: z.string().max(300).optional(), ignoreCase: z.boolean().optional(), earlyTermination: z.boolean().optional() }),
+  tool("get_more_search_results", "files:read", "Read a page of results from a search owned by this OAuth connection.", { sessionId: z.string().min(1).max(100), ...paging }),
+  tool("list_searches", "files:read", "List searches belonging to this OAuth connection."),
+  tool("stop_search", "files:read", "Stop an active search while keeping already collected results.", { sessionId: z.string().min(1).max(100) }, false),
+  tool("start_process", "terminal:execute", "Start a managed terminal process on this PC. It can continue beyond a single request. Shell commands run with the OS account permissions, not in a sandbox.", { command: z.string().min(1).max(65536), timeout_ms: wait, cwd: path7.optional(), shell: z.string().max(200).optional() }, false),
+  tool("interact_with_process", "terminal:execute", "Send input to a managed process and wait briefly for output. Sessions belong to this OAuth grant.", { pid: z.number().int().positive(), input: z.string().max(65536), timeout_ms: wait, wait_for_prompt: z.boolean().optional(), verbose_timing: z.boolean().optional() }, false),
+  tool("read_process_output", "terminal:execute", "Read buffered output of an owned process. offset 0 returns new output; positive/negative offsets page from beginning/end.", { pid: z.number().int().positive(), ...paging, timeout_ms: wait }),
+  tool("list_sessions", "terminal:execute", "List this OAuth connection's managed terminal sessions."),
+  tool("force_terminate", "terminal:execute", "Terminate an owned terminal session and its child process tree.", { pid: z.number().int().positive() }, false),
+  tool("list_processes", "terminal:execute", "List operating-system processes with available CPU and memory information."),
+  tool("kill_process", "terminal:execute", "Terminate an owned session, or an unrelated OS process only with confirm:true. The agent, its ancestors and other OAuth grants are protected.", { pid: z.number().int().positive(), confirm: z.boolean().optional() }, false),
+  tool("run_command", "terminal:execute", "Run a bounded shell command on this PC (maximum 25 seconds). For persistent work use start_process.", { command: z.string().min(1).max(4096), timeoutSeconds: z.number().int().min(1).max(25).default(15) }, false)
+];
+var TOOL_NAMES = TOOL_DEFS.map((t) => t.name);
+
+// src/agent/version.mjs
+var AGENT_VERSION = "0.3.0";
+
+// src/agent/runtime.mjs
+var states3 = /* @__PURE__ */ new WeakMap();
+var documentExtensions = /* @__PURE__ */ new Set([".pdf", ".docx", ".xlsx", ".xls", ".xlsm", ".png", ".jpg", ".jpeg", ".gif", ".webp"]);
+var processTools = /* @__PURE__ */ new Set(["start_process", "interact_with_process", "read_process_output", "list_sessions", "force_terminate", "list_processes", "kill_process"]);
+var searchTools = /* @__PURE__ */ new Set(["start_search", "get_more_search_results", "list_searches", "stop_search"]);
+var metaTools = /* @__PURE__ */ new Set(["get_config", "get_prompts", "get_recent_tool_calls", "get_usage_stats"]);
+function state(config) {
+  let s = states3.get(config);
+  if (!s) {
+    s = { startedAt: Date.now(), policyEpoch: 0, grants: /* @__PURE__ */ new Map(), clients: /* @__PURE__ */ new Map() };
+    states3.set(config, s);
+  }
+  return s;
+}
+function grantState(config, context) {
+  const s = state(config), id = context.grantId || "local";
+  if (!s.grants.has(id)) {
+    if (s.grants.size >= 32) s.grants.delete(s.grants.keys().next().value);
+    s.grants.set(id, { calls: 0, failed: 0, totalMs: 0, tools: {}, history: [] });
+  }
+  return s.grants.get(id);
+}
+function requested(args) {
+  const p = args.path ?? args.file_path ?? args.filePath;
+  if (typeof p !== "string" || !p.trim()) throw new Error("A relative file path is required");
+  return p;
+}
+function bounded2(value, limit = 8192) {
+  const s = JSON.stringify(value);
+  return s.length > limit ? { preview: s.slice(0, limit), truncated: true } : value;
+}
+function publicAddress(address) {
+  if (net.isIP(address) === 4) {
+    const [a, b] = address.split(".").map(Number);
+    return !(a === 0 || a === 10 || a === 127 || a >= 224 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && (b === 168 || b === 0) || a === 100 && b >= 64 && b <= 127 || a === 198 && (b === 18 || b === 19));
+  }
+  return net.isIP(address) === 6 && /^[23][0-9a-f]{3}:/i.test(address);
+}
+async function readUrl(value, redirects = 0) {
+  const url = new URL(value);
+  if (url.protocol !== "https:" || url.username || url.password || url.port && url.port !== "443") throw new Error("Only public HTTPS URLs without credentials are supported");
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  const addresses = net.isIP(host) ? [{ address: host, family: net.isIP(host) }] : await dns.lookup(host, { all: true });
+  if (!addresses.length || addresses.some((a) => !publicAddress(a.address))) throw new Error("Private/local URL addresses are not allowed");
+  const address = addresses[0];
+  return new Promise((resolve, reject) => {
+    const req = https.get(url, { lookup: (_hostname, options, cb) => options.all ? cb(null, [address]) : cb(null, address.address, address.family), timeout: 15e3 }, (res) => {
+      if ([301, 302, 303, 307, 308].includes(res.statusCode)) {
+        res.resume();
+        if (redirects >= 3 || !res.headers.location) {
+          reject(new Error("Too many redirects"));
+          return;
+        }
+        readUrl(new URL(res.headers.location, url), redirects + 1).then(resolve, reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error("URL returned HTTP " + res.statusCode));
+        return;
+      }
+      if (!/^(text\/|application\/(json|xml|javascript|xhtml\+xml))/.test(res.headers["content-type"] || "")) {
+        res.resume();
+        reject(new Error("URL reads support text, JSON and XML. Download binary documents into the approved folder first."));
+        return;
+      }
+      const chunks = [];
+      let size = 0;
+      res.on("data", (chunk) => {
+        size += chunk.length;
+        if (size > 256 * 1024) {
+          req.destroy(new Error("URL exceeds 256 KiB response limit"));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      res.on("end", () => resolve({ url: url.href, content: Buffer.concat(chunks).toString("utf8"), bytes: size }));
+      res.on("error", reject);
+    });
+    req.on("timeout", () => req.destroy(new Error("URL request timed out")));
+    req.on("error", reject);
+  });
+}
+var prompts = [
+  { id: "onb2_01", title: "Organize a work folder", prompt: "Inspect files in the approved folder, propose a grouping, and ask before moving or renaming existing files." },
+  { id: "onb2_02", title: "Explain a codebase", prompt: "List the repository and search for entry points. Read relevant files and explain architecture with references. Do not execute project scripts unless requested." },
+  { id: "onb2_03", title: "Create a knowledge base", prompt: "Read the selected notes and propose an index. Create organized documents only after the user chooses the destination and content." },
+  { id: "onb2_04", title: "Analyze a data file", prompt: "Inspect the file metadata and a bounded sample. Analyze the selected data, report assumptions and preserve the original file." },
+  { id: "onb2_05", title: "Check system health", prompt: "Inspect device information and available process statistics. Explain findings; ask before terminating any process or changing settings." }
+];
+async function applyPreference(config, args) {
+  const { key, value } = args;
+  const previous = config[key];
+  if (key === "allowedDirectories") {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 20) throw new Error("At least one approved subdirectory is required; empty never grants full-disk access");
+    const base = await fs6.realpath(config.root), dirs = [];
+    for (const item of value) {
+      if (typeof item !== "string") throw new Error("Invalid directory");
+      const rel = path8.isAbsolute(item) ? path8.relative(base, item) : item;
+      const target = await safePath({ ...config, allowedDirectories: void 0 }, rel || ".");
+      if (!(await fs6.stat(target)).isDirectory()) throw new Error("Not a directory");
+      dirs.push(target);
+    }
+    config.allowedDirectories = dirs;
+  } else if (key === "blockedCommands") {
+    if (!Array.isArray(value) || value.length > 100 || value.some((x) => typeof x !== "string" || !x.trim() || x.length > 200)) throw new Error("Invalid command list");
+    config.blockedCommands = [...value];
+  } else if (key === "defaultShell") {
+    const allowed = process.platform === "win32" ? ["powershell.exe", "pwsh.exe", "cmd.exe"] : ["/bin/sh", "/bin/bash", "/bin/zsh"];
+    if (!allowed.includes(value)) throw new Error("Unsupported shell");
+    config.defaultShell = value;
+  } else if (["fileReadLineLimit", "fileWriteLineLimit"].includes(key)) {
+    if (!Number.isInteger(value) || value < 1 || value > 2e3) throw new Error("Line limit must be 1 through 2000");
+    config[key] = value;
+  } else if (key === "telemetryEnabled") {
+    if (value !== false) throw new Error("CetriX does not send telemetry; this setting can only be false");
+    config.telemetryEnabled = false;
+  } else throw new Error("Configuration key cannot be changed remotely");
+  const preferences = Object.fromEntries(["allowedDirectories", "blockedCommands", "defaultShell", "fileReadLineLimit", "fileWriteLineLimit", "telemetryEnabled"].filter((k) => config[k] !== void 0).map((k) => [k, config[k]]));
+  try {
+    await config.savePreferences?.(preferences);
+  } catch (error) {
+    if (previous === void 0) delete config[key];
+    else config[key] = previous;
+    throw error;
+  }
+  if (key === "allowedDirectories") {
+    state(config).policyEpoch++;
+    await cleanupRuntime(config);
+  }
+  return { updated: true, key, value: config[key] };
+}
+function setPreference(config, args, context) {
+  const s = state(config), run2 = (s.preferenceQueue || Promise.resolve()).then(() => {
+    if (context.isActive && !context.isActive()) throw new Error("Authorization ended");
+    return applyPreference(config, args);
+  });
+  s.preferenceQueue = run2.catch(() => {
+  });
+  return run2;
+}
+async function readAny(config, args) {
+  if (args.isUrl) return readUrl(requested(args));
+  const target = await safePath(config, requested(args));
+  return documentExtensions.has(path8.extname(target).toLowerCase()) ? readDocument(config, target, args) : executeFilesystemTool(config, "read_file", args);
+}
+async function dispatch(config, tool2, args, context) {
+  if (context.isActive && !context.isActive()) throw new Error("Authorization ended");
+  if (tool2 === "ping_device") return { pong: true, deviceId: config.deviceId, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  if (tool2 === "shutdown_device") return { stopping: true, deviceId: config.deviceId, message: "Agent is stopping. Restart it locally to reconnect." };
+  if (tool2 === "get_config") return { version: AGENT_VERSION, allowedDirectories: config.allowedDirectories || [config.root], approvedRoot: config.root, allowWrite: !!config.allowWrite, allowShell: !!config.allowShell, blockedCommands: config.blockedCommands || [], defaultShell: config.defaultShell || (process.platform === "win32" ? "powershell.exe" : "/bin/sh"), fileReadLineLimit: config.fileReadLineLimit || 1e3, fileWriteLineLimit: config.fileWriteLineLimit || 50, telemetryEnabled: false, currentClient: context.client || null, clientHistory: [...state(config).clients.values()], systemInfo: { platform: process.platform, arch: process.arch, release: os.release(), hostname: os.hostname(), node: process.version, cpus: os.cpus().length, totalMemory: os.totalmem(), freeMemory: os.freemem() } };
+  if (tool2 === "set_config_value") return setPreference(config, args, context);
+  if (tool2 === "get_prompts") {
+    if (!args.promptId) return { prompts: prompts.map(({ id, title }) => ({ id, title })) };
+    const p = prompts.find((p2) => p2.id === args.promptId);
+    if (!p) throw new Error("Unknown prompt ID");
+    return p;
+  }
+  if (tool2 === "get_usage_stats") {
+    const { history, ...stats } = grantState(config, context);
+    return { since: new Date(state(config).startedAt).toISOString(), ...stats };
+  }
+  if (tool2 === "get_recent_tool_calls") {
+    const entries = grantState(config, context).history, offset = args.offset ?? 0, start2 = offset < 0 ? Math.max(0, entries.length + offset) : offset;
+    return { total: entries.length, calls: entries.slice(start2, start2 + (args.length || 100)).map((entry) => args.includeContent ? entry : Object.fromEntries(Object.entries(entry).filter(([key]) => !["args", "result"].includes(key)))) };
+  }
+  if (tool2 === "read_file") return readAny(config, args);
+  if (tool2 === "read_multiple_files") {
+    const results = [];
+    let size = 0;
+    for (const p of args.paths) {
+      let result;
+      try {
+        result = { path: p, result: await readAny(config, { ...args, path: p }) };
+      } catch (error) {
+        result = { path: p, error: error.message };
+      }
+      size += Buffer.byteLength(JSON.stringify(result));
+      if (size > 640 * 1024) {
+        results.push({ path: p, error: "Combined response limit reached; read remaining files separately" });
+        break;
+      }
+      results.push(result);
+    }
+    const hasImages = results.some((r) => Array.isArray(r.result?.content));
+    return hasImages ? { content: results.flatMap((r) => Array.isArray(r.result?.content) ? [{ type: "text", text: r.path }, ...r.result.content] : [{ type: "text", text: JSON.stringify(r) }]) } : { files: results };
+  }
+  if (["write_file", "edit_block"].includes(tool2)) {
+    const target = await safePath(config, requested(args), { write: tool2 === "write_file" });
+    if (documentExtensions.has(path8.extname(target).toLowerCase())) return tool2 === "write_file" ? writeDocument(config, target, args) : editDocument(config, target, args);
+  }
+  if (tool2 === "write_pdf") return writePdf(config, { ...args, path: requested(args) });
+  if (processTools.has(tool2)) return executeProcessTool(config, tool2, args, context);
+  if (searchTools.has(tool2)) return executeSearchTool(config, tool2, args, context);
+  if (tool2 === "run_command") {
+    const deadline = Date.now() + (args.timeoutSeconds || 15) * 1e3;
+    let result = await executeProcessTool(config, "start_process", { command: args.command, timeout_ms: Math.max(0, deadline - Date.now()) }, context), output = result.output || "";
+    while (result.status === "running" && Date.now() < deadline && Buffer.byteLength(output) <= 65536) {
+      result = await executeProcessTool(config, "read_process_output", { pid: result.pid, timeout_ms: Math.max(0, deadline - Date.now()) }, context);
+      output += result.output || "";
+    }
+    const terminated = result.status === "running", truncated = Buffer.byteLength(output) > 65536;
+    if (terminated) result = await executeProcessTool(config, "force_terminate", { pid: result.pid }, context);
+    return { stdout: Buffer.from(output).subarray(0, 65536).toString("utf8"), stderr: "", outputMerged: true, exitCode: result.exitCode, signal: result.signal, terminated, truncated, pid: result.pid };
+  }
+  const info = await executeFilesystemTool(config, tool2, args);
+  if (tool2 === "get_file_info" && [".xlsx", ".xls", ".xlsm"].includes(path8.extname(requested(args)).toLowerCase())) {
+    const doc = await readDocument(config, await safePath(config, requested(args)), { metadataOnly: true });
+    return { ...info, ...doc };
+  }
+  return info;
+}
+async function executeRuntimeTool(config, tool2, args = {}, context = {}) {
+  const def = TOOL_DEFS.find((d) => d.name === tool2);
+  if (!def) throw new Error("Unknown tool");
+  if (def.scope === "files:write" && !config.allowWrite) throw new Error("File writes are disabled on this PC");
+  if (def.scope === "terminal:execute" && !config.allowShell) throw new Error("Shell execution is disabled on this PC");
+  const parsed = def.schema.parse(args), stats = grantState(config, context), started = Date.now();
+  const epoch = state(config).policyEpoch, liveContext = { ...context, isActive: () => (!context.isActive || context.isActive()) && (tool2 === "set_config_value" || state(config).policyEpoch === epoch) };
+  if (context.client) {
+    const s = state(config);
+    s.clients.set(context.client.id, { ...context.client, lastSeen: (/* @__PURE__ */ new Date()).toISOString() });
+    if (s.clients.size > 100) s.clients.delete(s.clients.keys().next().value);
+  }
+  if (["run_command", "start_process", "interact_with_process"].includes(tool2)) {
+    const command = String(parsed.command ?? parsed.input ?? "").toLowerCase();
+    for (const blocked of config.blockedCommands || []) if (command.includes(blocked.toLowerCase())) throw new Error("Command matches the configured block list");
+  }
+  let result, success = false;
+  try {
+    result = await dispatch(config, tool2, parsed, liveContext);
+    if (!liveContext.isActive()) {
+      await cleanupRuntime(config, { grantId: context.grantId });
+      throw new Error("Authorization or directory policy changed");
+    }
+    if (Buffer.byteLength(JSON.stringify(result)) > 900 * 1024) throw new Error("Response too large; request a smaller range");
+    success = true;
+    return result;
+  } finally {
+    if (!metaTools.has(tool2)) {
+      stats.calls++;
+      if (!success) stats.failed++;
+      stats.totalMs += Date.now() - started;
+      stats.tools[tool2] = (stats.tools[tool2] || 0) + 1;
+      stats.history.push({ tool: tool2, at: new Date(started).toISOString(), durationMs: Date.now() - started, success, args: bounded2(parsed), result: bounded2(result ?? null) });
+      if (stats.history.length > 100) stats.history.shift();
+    }
+  }
+}
+async function cleanupRuntime(config, filter = {}) {
+  await Promise.allSettled([cleanupProcessSessions(config, filter), cleanupSearchSessions(config, filter)]);
+  const s = states3.get(config);
+  if (filter.grantId) s?.grants.delete(filter.grantId);
+  else if (s) s.grants.clear();
+}
+
+// src/agent/client.mjs
+function connectAgent(config, { onReady = () => {
+}, onStatus = () => {
+}, onShutdown = () => {
+}, reconnect = true, execute = executeRuntimeTool } = {}) {
+  let socket, timer, closed = false, retry = 0, generation = 0;
+  const revoked = /* @__PURE__ */ new Set();
+  const stop = () => {
+    closed = true;
+    generation++;
+    clearTimeout(timer);
+    socket?.close();
+    return cleanupRuntime(config);
+  };
+  const connect = () => {
+    if (closed) return;
+    const url = new URL("/agent", config.server);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    socket = new WebSocket2(url, { maxPayload: 1024 * 1024 });
+    let ready = false, active2 = 0;
+    const seen = /* @__PURE__ */ new Set();
+    const authTimer = setTimeout(() => {
+      if (!ready) socket.close();
+    }, 2e4);
+    socket.on("message", async (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (msg.type === "challenge" && !ready) {
+          if (typeof msg.nonce !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(msg.nonce)) throw new Error("Invalid server challenge");
+          const signature = sign(null, Buffer.from(proofMessage(config.deviceId, msg.nonce)), config.privateKey).toString("base64url");
+          const tools = TOOL_DEFS.filter((d) => (d.scope !== "files:write" || config.allowWrite) && (d.scope !== "terminal:execute" || config.allowShell)).map((d) => d.name);
+          socket.send(JSON.stringify({ type: "auth", deviceId: config.deviceId, signature, version: AGENT_VERSION, tools }));
+          return;
+        }
+        if (msg.type === "ready" && msg.deviceId === config.deviceId) {
+          ready = true;
+          retry = 0;
+          clearTimeout(authTimer);
+          onStatus("online");
+          onReady();
+          return;
+        }
+        if (ready && msg.type === "revoke" && typeof msg.grantId === "string") {
+          revoked.add(msg.grantId);
+          if (revoked.size > 2e3) revoked.delete(revoked.values().next().value);
+          await cleanupRuntime(config, { grantId: msg.grantId });
+          return;
+        }
+        if (ready && msg.type === "call" && typeof msg.id === "string" && !seen.has(msg.id)) {
+          const current = socket;
+          seen.add(msg.id);
+          if (seen.size > 2e3) seen.delete(seen.values().next().value);
+          if (active2 >= 8) {
+            current.send(JSON.stringify({ type: "result", id: msg.id, error: "Agent is busy" }));
+            return;
+          }
+          active2++;
+          const lease = generation, grantId = msg.context?.grantId;
+          const context = { grantId, client: msg.context?.client, isActive: () => !closed && lease === generation && current === socket && !revoked.has(grantId) };
+          try {
+            if (!context.isActive()) throw new Error("Authorization ended");
+            const result = await execute(config, msg.tool, msg.args || {}, context);
+            if (context.isActive() && current.readyState === WebSocket2.OPEN) current.send(JSON.stringify({ type: "result", id: msg.id, result }), (error) => {
+              if (!error && msg.tool === "shutdown_device") void stop().then(onShutdown);
+            });
+          } catch (error) {
+            if (current.readyState === WebSocket2.OPEN) current.send(JSON.stringify({ type: "result", id: msg.id, error: error.message }));
+          } finally {
+            active2--;
+          }
+        }
+      } catch {
+        socket.close(1008, "Invalid relay message");
+      }
+    });
+    socket.on("error", () => onStatus("connection-error"));
+    socket.on("close", (code) => {
+      generation++;
+      void cleanupRuntime(config);
+      clearTimeout(authTimer);
+      onStatus(code === 1008 ? "authorization-rejected" : "offline");
+      if (!closed && reconnect && code !== 1008) {
+        timer = setTimeout(connect, Math.min(3e4, 1e3 * 2 ** Math.min(retry++, 5)) + Math.random() * 500);
+      }
+    });
+  };
+  connect();
+  return { close: stop, get socket() {
+    return socket;
+  } };
+}
+
+// src/agent/entry.mjs
+var shellQuote = (value) => "'" + value.replaceAll("'", process.platform === "win32" ? "''" : "'\\''") + "'";
+var version = "0.3.0";
+var remoteServer = "https://connect.cetrix.app";
+var controlCharacters = /[\u0000-\u001f\u007f]/;
+function serverOrigin(value) {
+  if (typeof value !== "string" || value.length > 2048 || controlCharacters.test(value)) throw new Error("Invalid server origin");
+  const u = new URL(value);
+  if (u.pathname !== "/" || u.search || u.hash || u.username || u.password) throw new Error("Server must be an origin without credentials");
+  if (u.protocol !== "https:" && !(u.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(u.hostname))) throw new Error("HTTPS required except on loopback");
+  return u.origin;
+}
+function decodeOptions(value) {
+  if (value.length > 16384 || !value.length || !/^[A-Za-z0-9_-]+$/.test(value)) throw new Error("Invalid --options: expected base64url JSON");
+  const bytes = Buffer.from(value, "base64url");
+  if (bytes.length > 8192 || bytes.toString("base64url") !== value) throw new Error("Invalid --options encoding");
+  let decoded;
+  try {
+    decoded = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new Error("Invalid --options JSON");
+  }
+  if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) throw new Error("Invalid --options object");
+  const fields = { server: "string", root: "string", name: "string", allowWrite: "boolean", allowShell: "boolean" };
+  for (const [key, value2] of Object.entries(decoded)) {
+    if (!Object.hasOwn(fields, key) || typeof value2 !== fields[key]) throw new Error("Invalid --options field: " + key);
+  }
+  return decoded;
+}
+async function prepareAgentOptions(args, { npmMode = false, input = process.stdin, output = process.stdout, isTTY = !!(input.isTTY && output.isTTY), question } = {}) {
+  const { values: v, positionals: p } = parseArgs({ args, allowPositionals: true, options: { server: { type: "string" }, root: { type: "string" }, name: { type: "string" }, config: { type: "string" }, options: { type: "string" }, "allow-write": { type: "boolean" }, "allow-shell": { type: "boolean" }, "no-browser": { type: "boolean" }, help: { type: "boolean" } } });
+  if (v.help || !p.length && !npmMode) return { help: true };
+  if (p.length > 1) throw new Error("Choose one command: remote, setup, or run. Use --help.");
+  const command = p[0] || (npmMode ? "remote" : void 0);
+  if (!["remote", "setup", "run"].includes(command)) throw new Error("Expected remote, setup, or run. Use --help.");
+  if (v.options !== void 0) {
+    if (command !== "remote") throw new Error("--options is only supported by remote");
+    const decoded = decodeOptions(v.options);
+    for (const [source, target] of [["server", "server"], ["root", "root"], ["name", "name"], ["allowWrite", "allow-write"], ["allowShell", "allow-shell"]]) {
+      if (decoded[source] === void 0) continue;
+      if (v[target] !== void 0) throw new Error("Do not combine --options " + source + " with --" + target);
+      v[target] = decoded[source];
+    }
+  }
+  if (command !== "remote") return { command, values: v };
+  v.server = serverOrigin(v.server || remoteServer);
+  if (!v.root && !isTTY) throw new Error('A data folder is required. Run remote in an interactive terminal, or add --root "C:\\Work" (an existing folder). No folder is granted automatically.');
+  let prompts2;
+  const ask = question || ((prompt) => {
+    prompts2 ||= createInterface({ input, output });
+    return prompts2.question(prompt);
+  });
+  try {
+    if (v.name === void 0 && isTTY) v.name = (await ask("Ten may [" + os2.hostname() + "]: ")).trim() || os2.hostname();
+    if (!v.root) v.root = (await ask("Thu muc du lieu (duong dan day du): ")).trim();
+  } finally {
+    prompts2?.close();
+  }
+  v.name = (v.name ?? os2.hostname()).trim();
+  if (!v.name || v.name.length > 100 || controlCharacters.test(v.name)) throw new Error("Machine name must contain 1\u2013100 characters without control characters");
+  v.root = v.root.trim();
+  if (v.root.startsWith('"') && v.root.endsWith('"')) v.root = v.root.slice(1, -1);
+  if (v.root.length > 1024 || controlCharacters.test(v.root) || !path9.isAbsolute(v.root)) throw new Error("Select an existing data folder using its full absolute path");
+  let root;
+  try {
+    root = await fs7.realpath(v.root);
+    if (!(await fs7.stat(root)).isDirectory()) throw new Error("Not a directory");
+  } catch {
+    throw new Error("Data folder does not exist or cannot be opened: " + v.root);
+  }
+  if (root === path9.parse(root).root) throw new Error("Select a specific work folder, not a drive root");
+  v.root = root;
+  return { command: "setup", values: v };
+}
+function openBrowser(url) {
+  const child = process.platform === "win32" ? spawn4("rundll32.exe", ["url.dll,FileProtocolHandler", url], { windowsHide: true, stdio: "ignore" }) : spawn4(process.platform === "darwin" ? "open" : "xdg-open", [url], { stdio: "ignore" });
+  child.on("error", () => {
+  });
+  child.unref();
+}
+async function post(server, route, body) {
+  const response = await fetch(server + route, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body), signal: AbortSignal.timeout(15e3), redirect: "error" });
+  const data = await response.json();
+  return { ok: response.ok, data };
+}
+async function runAgent(args = process.argv.slice(2), options = {}) {
+  const { help, command, values: v } = await prepareAgentOptions(args, options);
+  if (help) {
+    console.log("CetriX Connect agent " + version + "\n\nQuick connect: npx --yes cetrix-connect@" + version + ' remote\nRemote options: --name "PC 01" --root "C:\\Work" --server https://your-host\nSetup: node dist/agent.mjs setup --server https://your-host --root "C:\\Work" --name "PC 01"\nOptional explicit permissions: --allow-write --allow-shell\nRun: ' + (options.npmMode ? "npx --yes cetrix-connect@" + version : "node dist/agent.mjs") + ' run --config "path-to-device.json"\n\nDefault: read-only. Keep the agent open; Ctrl+C disconnects.');
+    return;
+  }
+  let config, filename;
+  if (command === "setup") {
+    if (!v.server || !v.root) throw new Error("--server and --root are required. No home-directory access is granted by default.");
+    const server = serverOrigin(v.server), root = await fs7.realpath(v.root);
+    if (!(await fs7.stat(root)).isDirectory() || root === path9.parse(root).root) throw new Error("Select a specific work folder, not a drive root");
+    const stateDir = process.platform === "win32" ? path9.join(process.env.LOCALAPPDATA || os2.homedir(), "CetriX", "Connect", "agents") : path9.join(os2.homedir(), ".local", "share", "cetrix-connect", "agents");
+    filename = path9.resolve(v.config || path9.join(stateDir, randomUUID5() + ".json"));
+    try {
+      await fs7.access(filename);
+      throw new Error("Config already exists; use run or choose a new config path");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const { publicKey, privateKey } = generateKeyPairSync("ed25519", { publicKeyEncoding: { type: "spki", format: "pem" }, privateKeyEncoding: { type: "pkcs8", format: "pem" } });
+    const name = v.name || os2.hostname(), allowWrite = !!v["allow-write"], allowShell = !!v["allow-shell"];
+    console.log("CetriX Connect - " + name + "\nApproved root: " + root + "\nWrite: " + allowWrite + " | Shell: " + allowShell);
+    if (allowShell) console.log("WARNING: Shell runs with this OS account privileges. It is NOT sandboxed to the root folder.");
+    const begun = await post(server, "/api/enrollment/start", { name, root, publicKey, allowWrite, allowShell });
+    if (!begun.ok) throw new Error(begun.data.error_description || "Enrollment failed");
+    const enrollment = begun.data;
+    console.log("\nPAIRING CODE: " + enrollment.user_code + "\nFingerprint: " + enrollment.fingerprint + "\nConfirm: " + enrollment.verification_uri_complete);
+    if (!v["no-browser"]) openBrowser(enrollment.verification_uri_complete);
+    const deadline = Date.now() + enrollment.expires_in * 1e3;
+    let paired;
+    while (Date.now() < deadline) {
+      await sleep(5e3);
+      const polled = await post(server, "/api/enrollment/poll", { device_code: enrollment.device_code });
+      if (polled.ok) {
+        paired = polled.data;
+        break;
+      }
+      if (!["authorization_pending", "slow_down"].includes(polled.data.error)) throw new Error(polled.data.error_description || "Enrollment failed");
+    }
+    if (!paired) throw new Error("Pairing expired. Run setup again.");
+    config = { server, root, name, allowWrite, allowShell, deviceId: paired.device_id, privateKey, publicKey, deniedPaths: [stateDir, path9.dirname(filename), path9.join(projectDir, "data"), path9.resolve("data")] };
+    await saveIdentity(filename, config);
+    const restart = options.npmMode ? "npx --yes cetrix-connect@" + version : "node " + shellQuote(path9.resolve(process.argv[1]));
+    console.log("\nMCP endpoint: " + paired.endpoint + "\nIdentity saved to: " + filename + "\nNext run: " + restart + " run --config " + shellQuote(filename));
+  } else if (command === "run") {
+    if (!v.config) throw new Error("--config is required");
+    filename = path9.resolve(v.config);
+    config = await loadIdentity(filename);
+    config.server = serverOrigin(config.server);
+    config.deniedPaths = [...config.deniedPaths || [], path9.dirname(filename), path9.join(projectDir, "data"), path9.resolve("data")];
+  } else throw new Error("Expected setup or run. Use --help.");
+  const settingsFile = filename + ".settings.json";
+  try {
+    const settings = JSON.parse(await fs7.readFile(settingsFile, "utf8"));
+    if (!settings || typeof settings !== "object" || Array.isArray(settings)) throw new Error("Invalid preferences object");
+    if (settings.allowedDirectories !== void 0 && (!Array.isArray(settings.allowedDirectories) || !settings.allowedDirectories.length || settings.allowedDirectories.length > 20 || settings.allowedDirectories.some((p) => typeof p !== "string" || !path9.isAbsolute(p) || p.includes("\0")))) throw new Error("Invalid allowed directories");
+    if (settings.blockedCommands !== void 0 && (!Array.isArray(settings.blockedCommands) || settings.blockedCommands.length > 100 || settings.blockedCommands.some((p) => typeof p !== "string" || !p.trim() || p.length > 200))) throw new Error("Invalid blocked commands");
+    for (const key of ["fileReadLineLimit", "fileWriteLineLimit"]) if (settings[key] !== void 0 && (!Number.isInteger(settings[key]) || settings[key] < 1 || settings[key] > 2e3)) throw new Error("Invalid line limit");
+    if (settings.defaultShell !== void 0 && !(process.platform === "win32" ? ["powershell.exe", "pwsh.exe", "cmd.exe"] : ["/bin/sh", "/bin/bash", "/bin/zsh"]).includes(settings.defaultShell)) throw new Error("Invalid default shell");
+    if (settings.telemetryEnabled !== void 0 && settings.telemetryEnabled !== false) throw new Error("Telemetry is not supported");
+    for (const key of ["blockedCommands", "defaultShell", "allowedDirectories", "fileReadLineLimit", "fileWriteLineLimit", "telemetryEnabled"]) if (settings[key] !== void 0) config[key] = settings[key];
+  } catch (error) {
+    if (error.code !== "ENOENT") throw new Error("Unable to load agent settings: " + error.message);
+  }
+  config.savePreferences = async (preferences) => {
+    const temporary = settingsFile + "." + randomUUID5() + ".tmp";
+    try {
+      await fs7.writeFile(temporary, JSON.stringify(preferences, null, 2), { mode: 384, flag: "wx" });
+      await fs7.rename(temporary, settingsFile);
+    } finally {
+      await fs7.unlink(temporary).catch(() => {
+      });
+    }
+  };
+  const agent = connectAgent(config, { onStatus: (status) => console.log((/* @__PURE__ */ new Date()).toISOString() + " " + status), onShutdown: () => process.exit(0) });
+  for (const sig of ["SIGINT", "SIGTERM"]) process.on(sig, () => {
+    Promise.resolve(agent.close()).finally(() => process.exit(0));
+  });
+}
+
+// src/agent/remote.mjs
+runAgent(process.argv.slice(2), { npmMode: true }).catch((error) => {
+  console.error("CetriX Connect:", error.message);
+  process.exitCode = 1;
+});