@anusornneal/chat-relay 0.7.0 → 0.7.2

package/README.md

@@ -131,6 +131,10 @@ Processes:
 
 Terminal:
 - `terminal_exec`
+- `terminal_batch_start`
+- `terminal_batch_status`
+- `terminal_batch_read`
+- `terminal_batch_cancel`
 - `terminal_start`
 - `terminal_start_shell`
 - `terminal_read`
@@ -225,6 +229,11 @@ The OpenAI domain verification token is served at `/.well-known/openai-apps-chal
 - `read_file` defaults to a 32 KiB content budget (max 48 KiB) and exposes deterministic `nextOffset` continuation.
 - `read_multiple_files` defaults to a 48 KiB aggregate budget (max 48 KiB). If not all requested files fit, use `nextIndex`; if an individual file is truncated, continue it with that entry's `nextOffset`.
 - One-shot terminal command: max 20 seconds.
+- `terminal_batch_start` accepts 2-20 jobs in one MCP call to avoid N-call E2E dispatch overhead. Each agent owns an independent FIFO queue and bounded execution pool.
+- Batch concurrency defaults to 4 and is capped at 8 per agent. Override with `TERMINAL_BATCH_CONCURRENCY`; queued jobs default to 64 and are capped at 256 via `TERMINAL_BATCH_MAX_QUEUED`.
+- Queue overflow fails fast with `queue_full` instead of spawning unbounded processes. Use `terminal_batch_status`, `terminal_batch_read`, and `terminal_batch_cancel` for lifecycle control.
+- Batch output retained in memory is capped at 8 KiB per job; completed batches are capped at 64 per agent and also expire after 30 minutes.
+- Scaling is horizontal by agent: each connected machine has its own queue/concurrency budget, so additional agents add execution capacity without sharing one local hot queue.
 - Persistent terminal sessions: up to 8 running sessions per local agent.
 - Terminal output buffer: bounded in memory; completed sessions retained for 30 minutes.
 - Filesystem reads/writes are bounded and restricted to configured `ALLOWED_ROOTS`.

package/agent/desktop-manager.mjs

@@ -1,175 +1,319 @@
-import { execFile } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import path from "node:path";
-
-const MAX_SCREENSHOT_BINARY_BYTES = 32 * 1024;
-const POWERSHELL_TIMEOUT_MS = 15_000;
-const MAX_TEXT_LENGTH = 8192;
-const helperPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "windows-desktop.ps1");
-
-const KEY_CODES = new Map([
-  ["enter", 0x0D],
-  ["tab", 0x09],
-  ["escape", 0x1B],
-  ["backspace", 0x08],
-  ["delete", 0x2E],
-  ["arrowleft", 0x25],
-  ["arrowup", 0x26],
-  ["arrowright", 0x27],
-  ["arrowdown", 0x28],
-  ["home", 0x24],
-  ["end", 0x23],
-  ["pageup", 0x21],
-  ["pagedown", 0x22],
-  ["space", 0x20],
-  ...Array.from({ length: 12 }, (_, index) => ["f" + (index + 1), 0x70 + index]),
-  ...Array.from({ length: 26 }, (_, index) => [String.fromCharCode(97 + index), 0x41 + index]),
-  ...Array.from({ length: 10 }, (_, index) => [String(index), 0x30 + index]),
-]);
-
-function normalizedKey(value) {
-  return String(value || "").trim().toLowerCase().replace(/[\s_-]+/g, "");
-}
-
-function encodeArgs(args) {
-  return Buffer.from(JSON.stringify(args || {}), "utf8").toString("base64");
-}
-
-async function defaultRunner(operation, args) {
-  return new Promise((resolve) => {
-    execFile(
-      "powershell.exe",
-      [
-        "-NoLogo",
-        "-NoProfile",
-        "-NonInteractive",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-File",
-        helperPath,
-        "-Operation",
-        operation,
-        "-InputBase64",
-        encodeArgs(args),
-      ],
-      {
-        windowsHide: true,
-        timeout: POWERSHELL_TIMEOUT_MS,
-        maxBuffer: 512 * 1024,
-      },
-      (error, stdout) => {
-        const line = String(stdout || "").trim().split(/\r?\n/).filter(Boolean).at(-1);
-        if (!line) {
-          resolve({ ok: false, error: operation === "screenshot" ? "capture_failed" : "input_failed" });
-          return;
-        }
-        try {
-          resolve(JSON.parse(line));
-        } catch {
-          resolve({ ok: false, error: operation === "screenshot" ? "capture_failed" : "input_failed" });
-        }
-      },
-    );
-  });
-}
-
-export class DesktopManager {
-  constructor(options = {}) {
-    this.enabled = options.enabled ?? process.env.DESKTOP_ENABLED === "1";
-    this.platform = options.platform ?? process.platform;
-    this.runner = options.runner ?? defaultRunner;
-  }
-
-  getConfig() {
-    return {
-      enabled: this.enabled,
-      supported: this.platform === "win32",
-      platform: this.platform,
-    };
-  }
-
-  gate() {
-    if (!this.enabled) return { ok: false, error: "desktop_disabled" };
-    if (this.platform !== "win32") return { ok: false, error: "unsupported_platform" };
-    return null;
-  }
-
-  async screenshot() {
-    const gate = this.gate();
-    if (gate) return gate;
-
-    const result = await this.runner("screenshot", {});
-    if (!result?.ok) return result || { ok: false, error: "capture_failed" };
-    if (result.mimeType !== "image/jpeg" || typeof result.data !== "string") {
-      return { ok: false, error: "capture_failed" };
-    }
-
-    const binaryBytes = Buffer.from(result.data, "base64").byteLength;
-    if (binaryBytes <= 0 || binaryBytes > MAX_SCREENSHOT_BINARY_BYTES) {
-      return { ok: false, error: "screenshot_too_large" };
-    }
-
-    return {
-      ok: true,
-      mimeType: result.mimeType,
-      data: result.data,
-      width: Number(result.width),
-      height: Number(result.height),
-      desktopOriginX: Number(result.desktopOriginX),
-      desktopOriginY: Number(result.desktopOriginY),
-      desktopWidth: Number(result.desktopWidth),
-      desktopHeight: Number(result.desktopHeight),
-      scaleX: Number(result.scaleX),
-      scaleY: Number(result.scaleY),
-      byteLength: binaryBytes,
-    };
-  }
-
-  async mouseClick(input = {}) {
-    const gate = this.gate();
-    if (gate) return gate;
-
-    const x = Number(input.x);
-    const y = Number(input.y);
-    const button = String(input.button || "left").toLowerCase();
-    const clicks = Number(input.clicks ?? 1);
-
-    if (!Number.isInteger(x) || !Number.isInteger(y)) return { ok: false, error: "invalid_coordinates" };
-    if (!["left", "right", "middle"].includes(button)) return { ok: false, error: "invalid_button" };
-    if (clicks !== 1 && clicks !== 2) return { ok: false, error: "invalid_click_count" };
-
-    return this.runner("mouse_click", { x, y, button, clicks });
-  }
-
-  async keyboardInput(input = {}) {
-    const gate = this.gate();
-    if (gate) return gate;
-
-    const hasText = typeof input.text === "string" && input.text.length > 0;
-    const hasKey = typeof input.key === "string" && input.key.trim().length > 0;
-
-    if (hasText === hasKey) return { ok: false, error: "invalid_keyboard_input" };
-
-    if (hasText) {
-      if (input.text.length > MAX_TEXT_LENGTH) return { ok: false, error: "text_too_large" };
-      if (input.ctrl || input.alt || input.shift || input.win) {
-        return { ok: false, error: "invalid_keyboard_input" };
-      }
-      return this.runner("keyboard_input", { text: input.text });
-    }
-
-    const key = normalizedKey(input.key);
-    const keyCode = KEY_CODES.get(key);
-    if (!keyCode) return { ok: false, error: "unsupported_key" };
-
-    return this.runner("keyboard_input", {
-      keyCode,
-      ctrl: input.ctrl === true,
-      alt: input.alt === true,
-      shift: input.shift === true,
-      win: input.win === true,
-    });
-  }
-}
-
-export { KEY_CODES, MAX_SCREENSHOT_BINARY_BYTES };
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import readline from "node:readline";
+import { randomUUID } from "node:crypto";
+
+const MAX_SCREENSHOT_BINARY_BYTES = 32 * 1024;
+const POWERSHELL_TIMEOUT_MS = 15_000;
+const MAX_TEXT_LENGTH = 8192;
+const helperPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "windows-desktop-worker.ps1");
+
+const KEY_CODES = new Map([
+  ["enter", 0x0D],
+  ["tab", 0x09],
+  ["escape", 0x1B],
+  ["backspace", 0x08],
+  ["delete", 0x2E],
+  ["arrowleft", 0x25],
+  ["arrowup", 0x26],
+  ["arrowright", 0x27],
+  ["arrowdown", 0x28],
+  ["home", 0x24],
+  ["end", 0x23],
+  ["pageup", 0x21],
+  ["pagedown", 0x22],
+  ["space", 0x20],
+  ...Array.from({ length: 12 }, (_, index) => ["f" + (index + 1), 0x70 + index]),
+  ...Array.from({ length: 26 }, (_, index) => [String.fromCharCode(97 + index), 0x41 + index]),
+  ...Array.from({ length: 10 }, (_, index) => [String(index), 0x30 + index]),
+]);
+
+function normalizedKey(value) {
+  return String(value || "").trim().toLowerCase().replace(/[\s_-]+/g, "");
+}
+
+function normalizeKeyboardInput(input = {}) {
+  const hasText = typeof input.text === "string" && input.text.length > 0;
+  const hasKey = typeof input.key === "string" && input.key.trim().length > 0;
+
+  if (hasText === hasKey) return { ok: false, error: "invalid_keyboard_input" };
+
+  if (hasText) {
+    if (input.text.length > MAX_TEXT_LENGTH) return { ok: false, error: "text_too_large" };
+    if (input.ctrl || input.alt || input.shift || input.win) {
+      return { ok: false, error: "invalid_keyboard_input" };
+    }
+    return { ok: true, payload: { text: input.text } };
+  }
+
+  const key = normalizedKey(input.key);
+  const keyCode = KEY_CODES.get(key);
+  if (!keyCode) return { ok: false, error: "unsupported_key" };
+
+  return {
+    ok: true,
+    payload: {
+      keyCode,
+      ctrl: input.ctrl === true,
+      alt: input.alt === true,
+      shift: input.shift === true,
+      win: input.win === true,
+    },
+  };
+}
+
+class PersistentDesktopRunner {
+  constructor(options = {}) {
+    this.platform = options.platform ?? process.platform;
+    this.timeoutMs = Number(options.timeoutMs ?? POWERSHELL_TIMEOUT_MS);
+    this.process = null;
+    this.stdout = null;
+    this.pending = new Map();
+    this.stderr = "";
+  }
+
+  ensureStarted() {
+    if (this.platform !== "win32") return false;
+    if (this.process && !this.process.killed) return true;
+
+    const child = spawn("powershell.exe", [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-File",
+      helperPath,
+    ], {
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    this.process = child;
+    this.stderr = "";
+    this.stdout = readline.createInterface({ input: child.stdout });
+
+    this.stdout.on("line", (line) => {
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        return;
+      }
+      const pending = this.pending.get(message?.id);
+      if (!pending) return;
+      clearTimeout(pending.timer);
+      this.pending.delete(message.id);
+      pending.resolve(message.result ?? { ok: false, error: "desktop_worker_error" });
+    });
+
+    child.stderr.on("data", (chunk) => {
+      this.stderr = (this.stderr + String(chunk)).slice(-8192);
+    });
+
+    child.on("exit", () => {
+      const error = { ok: false, error: "desktop_worker_exited" };
+      for (const pending of this.pending.values()) {
+        clearTimeout(pending.timer);
+        pending.resolve(error);
+      }
+      this.pending.clear();
+      this.stdout?.close();
+      this.stdout = null;
+      this.process = null;
+    });
+
+    child.on("error", () => {
+      // exit handler settles pending work.
+    });
+
+    return true;
+  }
+
+  async run(operation, args) {
+    if (!this.ensureStarted() || !this.process?.stdin?.writable) {
+      return { ok: false, error: operation === "screenshot" ? "capture_failed" : "input_failed" };
+    }
+
+    const id = randomUUID();
+    const request = JSON.stringify({ id, operation, args: args || {} }) + "\n";
+
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        resolve({ ok: false, error: operation === "screenshot" ? "capture_timeout" : "input_timeout" });
+      }, this.timeoutMs);
+
+      this.pending.set(id, { resolve, timer });
+      this.process.stdin.write(request, (error) => {
+        if (!error) return;
+        clearTimeout(timer);
+        this.pending.delete(id);
+        resolve({ ok: false, error: operation === "screenshot" ? "capture_failed" : "input_failed" });
+      });
+    });
+  }
+
+  close() {
+    try { this.stdout?.close(); } catch {}
+    try { this.process?.kill(); } catch {}
+    this.stdout = null;
+    this.process = null;
+  }
+}
+
+export class DesktopManager {
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? process.env.DESKTOP_ENABLED === "1";
+    this.platform = options.platform ?? process.platform;
+    this.persistentRunner = options.persistentRunner ?? new PersistentDesktopRunner({ platform: this.platform });
+    this.runner = options.runner ?? ((operation, args) => this.persistentRunner.run(operation, args));
+  }
+
+  getConfig() {
+    return {
+      enabled: this.enabled,
+      supported: this.platform === "win32",
+      platform: this.platform,
+      transport: this.platform === "win32" ? "persistent-worker" : "unsupported",
+    };
+  }
+
+  gate() {
+    if (!this.enabled) return { ok: false, error: "desktop_disabled" };
+    if (this.platform !== "win32") return { ok: false, error: "unsupported_platform" };
+    return null;
+  }
+
+  async screenshot(input = {}) {
+    const gate = this.gate();
+    if (gate) return gate;
+
+    const monitor = input.monitor ?? "primary";
+    if (!(monitor === "primary" || monitor === "secondary" || (Number.isInteger(monitor) && monitor >= 0 && monitor <= 15))) {
+      return { ok: false, error: "invalid_monitor" };
+    }
+
+    const result = await this.runner("screenshot", { monitor });
+    return this.normalizeScreenshotResult(result);
+  }
+
+  normalizeScreenshotResult(result) {
+    if (!result?.ok) return result || { ok: false, error: "capture_failed" };
+    if (result.mimeType !== "image/jpeg" || typeof result.data !== "string") {
+      return { ok: false, error: "capture_failed" };
+    }
+
+    const binaryBytes = Buffer.from(result.data, "base64").byteLength;
+    if (binaryBytes <= 0 || binaryBytes > MAX_SCREENSHOT_BINARY_BYTES) {
+      return { ok: false, error: "screenshot_too_large" };
+    }
+
+    return {
+      ...result,
+      ok: true,
+      width: Number(result.width),
+      height: Number(result.height),
+      desktopOriginX: Number(result.desktopOriginX),
+      desktopOriginY: Number(result.desktopOriginY),
+      desktopWidth: Number(result.desktopWidth),
+      desktopHeight: Number(result.desktopHeight),
+      scaleX: Number(result.scaleX),
+      scaleY: Number(result.scaleY),
+      monitorIndex: Number(result.monitorIndex),
+      isPrimary: result.isPrimary === true,
+      deviceName: typeof result.deviceName === "string" ? result.deviceName : undefined,
+      byteLength: binaryBytes,
+    };
+  }
+
+  async mouseClick(input = {}) {
+    const gate = this.gate();
+    if (gate) return gate;
+
+    const x = Number(input.x);
+    const y = Number(input.y);
+    const button = String(input.button || "left").toLowerCase();
+    const clicks = Number(input.clicks ?? 1);
+
+    if (!Number.isInteger(x) || !Number.isInteger(y)) return { ok: false, error: "invalid_coordinates" };
+    if (!["left", "right", "middle"].includes(button)) return { ok: false, error: "invalid_button" };
+    if (clicks !== 1 && clicks !== 2) return { ok: false, error: "invalid_click_count" };
+
+    return this.runner("mouse_click", { x, y, button, clicks });
+  }
+
+  async keyboardInput(input = {}) {
+    const gate = this.gate();
+    if (gate) return gate;
+
+    const normalized = normalizeKeyboardInput(input);
+    if (!normalized.ok) return normalized;
+    return this.runner("keyboard_input", normalized.payload);
+  }
+
+  async step(input = {}) {
+    const gate = this.gate();
+    if (gate) return gate;
+
+    const actions = Array.isArray(input.actions) ? input.actions : [];
+    if (actions.length < 1 || actions.length > 20) return { ok: false, error: "invalid_step_actions" };
+
+    const normalizedActions = [];
+    for (const action of actions) {
+      if (!action || typeof action !== "object") return { ok: false, error: "invalid_step_action" };
+      if (action.type === "click") {
+        const x = Number(action.x);
+        const y = Number(action.y);
+        const button = String(action.button || "left").toLowerCase();
+        const clicks = Number(action.clicks ?? 1);
+        if (!Number.isInteger(x) || !Number.isInteger(y)) return { ok: false, error: "invalid_coordinates" };
+        if (!["left", "right", "middle"].includes(button)) return { ok: false, error: "invalid_button" };
+        if (clicks !== 1 && clicks !== 2) return { ok: false, error: "invalid_click_count" };
+        normalizedActions.push({ type: "click", x, y, button, clicks });
+        continue;
+      }
+
+      if (action.type === "text" || action.type === "key") {
+        const normalized = normalizeKeyboardInput(action);
+        if (!normalized.ok) return normalized;
+        normalizedActions.push({ type: action.type, ...normalized.payload });
+        continue;
+      }
+
+      if (action.type === "wait") {
+        const ms = Number(action.ms);
+        if (!Number.isInteger(ms) || ms < 0 || ms > 5000) return { ok: false, error: "invalid_wait" };
+        normalizedActions.push({ type: "wait", ms });
+        continue;
+      }
+
+      return { ok: false, error: "invalid_step_action" };
+    }
+
+    const monitor = input.monitor ?? "primary";
+    if (!(monitor === "primary" || monitor === "secondary" || (Number.isInteger(monitor) && monitor >= 0 && monitor <= 15))) {
+      return { ok: false, error: "invalid_monitor" };
+    }
+
+    const settleMs = input.settleMs === undefined ? 120 : Number(input.settleMs);
+    if (!Number.isInteger(settleMs) || settleMs < 0 || settleMs > 5000) return { ok: false, error: "invalid_settle_ms" };
+
+    const result = await this.runner("step", {
+      actions: normalizedActions,
+      captureAfter: input.captureAfter !== false,
+      settleMs,
+      monitor,
+    });
+
+    if (input.captureAfter === false) return result;
+    return this.normalizeScreenshotResult(result);
+  }
+
+  close() {
+    this.persistentRunner?.close?.();
+  }
+}
+
+export { KEY_CODES, MAX_SCREENSHOT_BINARY_BYTES, PersistentDesktopRunner };

package/agent/file-manager.mjs

@@ -9,7 +9,15 @@ const MAX_READ_RESPONSE_BYTES = 48 * 1024;
 const MIN_READ_RESPONSE_BYTES = 1024;
 const MAX_WRITE_BYTES = 256 * 1024;
 const MAX_SEARCH_FILES = 5000;
+const DEFAULT_LIST_LIMIT = 200;
+const MAX_LIST_LIMIT = 500;
+const DEFAULT_LIST_RESPONSE_BYTES = 48 * 1024;
 const SKIP_DIRS = new Set([".git", "node_modules", ".gradle", ".idea", ".wrangler"]);
+const ALLOWED_DOT_DIRS = new Set([".github"]);
+
+function skipWalkDirectory(name) {
+  return SKIP_DIRS.has(name) || (name.startsWith(".") && !ALLOWED_DOT_DIRS.has(name));
+}
 
 function splitRoots(spec) {
   if (!spec) return [process.cwd()];
@@ -82,31 +90,37 @@ export class FileManager {
     };
   }
 
-  async list(input, depth = 1) {
+  async list(input, depth = 1, offset = 0, limit = DEFAULT_LIST_LIMIT, maxBytes = DEFAULT_LIST_RESPONSE_BYTES) {
     const target = await this.#resolveExisting(input);
-    const maxDepth = Math.min(Math.max(Number(depth) || 1, 0), 3);
+    const numericDepth = Number(depth);
+    const maxDepth = Number.isFinite(numericDepth) ? Math.min(Math.max(Math.trunc(numericDepth), 0), 3) : 1;
+    const start = Math.max(Math.trunc(Number(offset) || 0), 0);
+    const pageLimit = Math.min(Math.max(Math.trunc(Number(limit) || DEFAULT_LIST_LIMIT), 1), MAX_LIST_LIMIT);
+    const responseBudget = boundedReadBytes(maxBytes, DEFAULT_LIST_RESPONSE_BYTES, 4 * 1024);
     const entries = [];
-    await this.#walkList(target, 0, maxDepth, entries);
-    return { path: target, entries };
+    await this.#walkList(target, 0, maxDepth, entries, start + pageLimit + 1);
+
+    const selected = entries.slice(start, start + pageLimit);
+    while (selected.length > 1 && byteSize({ path: target, entries: selected, offset: start }) > responseBudget) selected.pop();
+    if (selected.length === 1 && byteSize({ path: target, entries: selected, offset: start }) > responseBudget) throw new Error("list_entry_too_large");
+
+    const nextOffset = start + selected.length;
+    const hasMore = nextOffset < entries.length;
+    return { path: target, entries: selected, offset: start, limit: pageLimit, maxBytes: responseBudget, truncated: hasMore, nextOffset: hasMore ? nextOffset : null };
   }
 
-  async #walkList(current, level, maxDepth, output) {
+  async #walkList(current, level, maxDepth, output, stopAfter = 1001) {
     const items = await fs.readdir(current, { withFileTypes: true });
     items.sort((a, b) => a.name.localeCompare(b.name));
     for (const item of items) {
       const fullPath = path.join(current, item.name);
       let size = null;
       if (item.isFile()) size = (await fs.stat(fullPath)).size;
-      output.push({
-        path: fullPath,
-        name: item.name,
-        type: item.isDirectory() ? "directory" : item.isFile() ? "file" : "other",
-        size,
-      });
-      if (output.length >= 1000) return;
-      if (item.isDirectory() && level < maxDepth && !SKIP_DIRS.has(item.name)) {
-        await this.#walkList(fullPath, level + 1, maxDepth, output);
-        if (output.length >= 1000) return;
+      output.push({ path: fullPath, name: item.name, type: item.isDirectory() ? "directory" : item.isFile() ? "file" : "other", size });
+      if (output.length >= stopAfter) return;
+      if (item.isDirectory() && level < maxDepth && !skipWalkDirectory(item.name)) {
+        await this.#walkList(fullPath, level + 1, maxDepth, output, stopAfter);
+        if (output.length >= stopAfter) return;
       }
     }
   }
@@ -305,12 +319,14 @@ export class FileManager {
       const needle = pattern.toLowerCase();
       let scanned = 0;
 
-      const walk = async (current) => {
-        if (session.results.length >= limit || scanned >= MAX_SEARCH_FILES) return;
+      const queue = [target];
+      while (queue.length > 0 && session.results.length < limit && scanned < MAX_SEARCH_FILES) {
+        const current = queue.shift();
         const items = await fs.readdir(current, { withFileTypes: true }).catch(() => []);
+        items.sort((a, b) => a.name.localeCompare(b.name));
         for (const item of items) {
           if (session.results.length >= limit || scanned >= MAX_SEARCH_FILES) break;
-          if (item.isDirectory() && SKIP_DIRS.has(item.name)) continue;
+          if (item.isDirectory() && skipWalkDirectory(item.name)) continue;
           const fullPath = path.join(current, item.name);
           scanned++;
 
@@ -330,12 +346,9 @@ export class FileManager {
               }
             }
           }
-
-          if (item.isDirectory()) await walk(fullPath);
+          if (item.isDirectory()) queue.push(fullPath);
         }
-      };
-
-      await walk(target);
+      }
       session.status = "COMPLETED";
       session.scanned = scanned;
     } catch (error) {