@anusornneal/chat-relay 0.7.1 → 0.7.2

package/agent/desktop-manager.mjs

@@ -1,183 +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(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 });
-    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),
-      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 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) {

package/agent/local-agent.mjs

@@ -66,7 +66,7 @@ async function handlePayload(payload) {
     case "fs.stat":
       return files.stat(payload.path);
     case "fs.list":
-      return files.list(payload.path, payload.depth);
+      return files.list(payload.path, payload.depth, payload.offset, payload.limit, payload.maxBytes);
     case "fs.read":
       return files.read(payload.path, payload.offset, payload.length, payload.maxBytes);
     case "fs.readMany":
@@ -97,13 +97,15 @@ async function handlePayload(payload) {
       return desktop.mouseClick(payload);
     case "desktop.keyboard.input":
       return desktop.keyboardInput(payload);
+    case "desktop.step":
+      return desktop.step(payload);
 
     case "terminal.exec":
       if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
       return terminals.exec(payload.command, payload.cwd, payload.timeoutMs);
     case "terminal.batch.start":
       if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
-      return terminals.batchStart(payload.jobs, { cwd: payload.cwd, timeoutMs: payload.timeoutMs, concurrency: payload.concurrency });
+      return terminals.batchStart(payload.jobs, { cwd: payload.cwd, timeoutMs: payload.timeoutMs, concurrency: payload.concurrency, observability: payload.observability });
     case "terminal.batch.status":
       if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
       return terminals.batchStatus(payload.batchId);
@@ -115,10 +117,10 @@ async function handlePayload(payload) {
       return terminals.batchCancel(payload.batchId);
     case "terminal.start":
       if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
-      return terminals.start(payload.command, payload.cwd);
+      return terminals.start(payload.command, payload.cwd, payload.observability);
     case "terminal.shell.start":
       if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
-      return terminals.startShell(payload.cwd);
+      return terminals.startShell(payload.cwd, payload.observability);
     case "terminal.read":
       if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
       return terminals.read(payload.sessionId, payload.afterSeq, payload.maxChars);
@@ -131,6 +133,9 @@ async function handlePayload(payload) {
     case "terminal.list":
       if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
       return terminals.list();
+    case "terminal.observability":
+      if (!terminalEnabled) return { ok: false, error: "terminal_disabled" };
+      return terminals.observability();
 
     default:
       return { ok: false, error: "unknown_action" };
@@ -140,6 +145,7 @@ async function handlePayload(payload) {
 function requireReauthorization() {
   if (reauthorizationRequired) return;
   reauthorizationRequired = true;
+  desktop.close();
   process.exitCode = 2;
   console.error("Agent credential was revoked or rejected.");
   console.error('Recovery: run "chat-relay login --force", then "chat-relay remote".');
@@ -225,4 +231,12 @@ function connect() {
   });
 }
 
+function shutdown() {
+  desktop.close();
+}
+
+process.once("SIGINT", shutdown);
+process.once("SIGTERM", shutdown);
+process.once("exit", shutdown);
+
 connect();

package/agent/terminal-manager.mjs

@@ -119,22 +119,24 @@ export class TerminalManager {
     });
   }
 
-  start(command, cwd) {
+  start(command, cwd, observability) {
     validateCommand(command);
     return this.#spawnSession({
       type: "command",
       command,
       cwd: safeCwd(cwd),
       args: ["-NoLogo", "-NoProfile", "-Command", command],
+      observability,
     });
   }
 
-  startShell(cwd) {
+  startShell(cwd, observability) {
     return this.#spawnSession({
       type: "shell",
       command: "powershell",
       cwd: safeCwd(cwd),
       args: ["-NoLogo", "-NoProfile", "-NoExit", "-Command", "-"],
+      observability,
     });
   }
 
@@ -143,6 +145,45 @@ export class TerminalManager {
     return [...this.sessions.values()].map((session) => this.#summary(session));
   }
 
+  observability() {
+    this.#cleanup();
+    return {
+      ok: true,
+      sessions: [...this.sessions.values()].map((session) => ({
+        sessionId: session.id,
+        type: session.type,
+        status: session.status,
+        exitCode: session.exitCode,
+        startedAt: session.startedAt,
+        endedAt: session.endedAt,
+        ...(session.observability?.userId ? { userId: session.observability.userId } : {}),
+        ...(session.observability?.activityId ? { activityId: session.observability.activityId } : {}),
+        ...(session.observability?.toolCallId ? { toolCallId: session.observability.toolCallId } : {}),
+      })),
+      batches: [...this.batches.values()].map((batch) => ({
+        batchId: batch.batchId,
+        createdAt: batch.createdAt,
+        endedAt: batch.endedAt,
+        cancelled: batch.cancelled,
+        ...(batch.observability?.userId ? { userId: batch.observability.userId } : {}),
+        ...(batch.observability?.activityId ? { activityId: batch.observability.activityId } : {}),
+        ...(batch.observability?.toolCallId ? { toolCallId: batch.observability.toolCallId } : {}),
+        counts: this.#batchSummary(batch).counts,
+        jobs: batch.jobs.map((job) => ({
+          jobId: job.jobId,
+          status: job.status,
+          queuedAt: job.queuedAt,
+          startedAt: job.startedAt,
+          endedAt: job.endedAt,
+          durationMs: job.durationMs,
+          exitCode: job.exitCode,
+        })),
+      })),
+      activeExecJobs: this.activeBatchJobs,
+      queuedJobs: this.batchQueue.length,
+    };
+  }
+
   read(sessionId, afterSeq = 0, maxChars = MAX_READ_CHARS) {
     this.#cleanup();
     const session = this.#get(sessionId);
@@ -216,6 +257,7 @@ export class TerminalManager {
       endedAt: null,
       requestedConcurrency,
       cancelled: false,
+      observability: options.observability ?? null,
       jobs: jobs.map((input, index) => {
         const item = typeof input === "string" ? { command: input } : input;
         validateCommand(item?.command);
@@ -311,7 +353,7 @@ export class TerminalManager {
     };
   }
 
-  #spawnSession({ type, command, cwd, args }) {
+  #spawnSession({ type, command, cwd, args, observability }) {
     this.#cleanup();
     const running = [...this.sessions.values()].filter((session) => session.status === "running").length;
     if (running >= MAX_SESSIONS) throw new Error("too_many_sessions");
@@ -337,6 +379,7 @@ export class TerminalManager {
       chunks: [],
       nextSeq: 1,
       totalChars: 0,
+      observability: observability ?? null,
     };
 
     this.sessions.set(session.id, session);

package/agent/windows-desktop-worker.ps1

@@ -0,0 +1,380 @@
+param()
+
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+
+public static class ChatRelayNative {
+  public const uint INPUT_MOUSE = 0;
+  public const uint INPUT_KEYBOARD = 1;
+  public const uint KEYEVENTF_KEYUP = 0x0002;
+  public const uint KEYEVENTF_UNICODE = 0x0004;
+
+  [StructLayout(LayoutKind.Sequential)]
+  public struct MOUSEINPUT {
+    public int dx;
+    public int dy;
+    public uint mouseData;
+    public uint dwFlags;
+    public uint time;
+    public UIntPtr dwExtraInfo;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  public struct KEYBDINPUT {
+    public ushort wVk;
+    public ushort wScan;
+    public uint dwFlags;
+    public uint time;
+    public UIntPtr dwExtraInfo;
+  }
+
+  [StructLayout(LayoutKind.Explicit)]
+  public struct INPUTUNION {
+    [FieldOffset(0)] public MOUSEINPUT mi;
+    [FieldOffset(0)] public KEYBDINPUT ki;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  public struct INPUT {
+    public uint type;
+    public INPUTUNION U;
+  }
+
+  [DllImport("user32.dll")] public static extern uint SendInput(uint nInputs, INPUT[] pInputs, int cbSize);
+  [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y);
+  [DllImport("user32.dll")] public static extern bool SetProcessDPIAware();
+  [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+
+  public static bool MouseButton(uint downFlag, uint upFlag) {
+    var inputs = new INPUT[2];
+    inputs[0].type = INPUT_MOUSE;
+    inputs[0].U.mi.dwFlags = downFlag;
+    inputs[1].type = INPUT_MOUSE;
+    inputs[1].U.mi.dwFlags = upFlag;
+    return SendInput(2, inputs, Marshal.SizeOf(typeof(INPUT))) == 2;
+  }
+
+  public static bool Key(ushort virtualKey, bool down) {
+    var input = new INPUT[1];
+    input[0].type = INPUT_KEYBOARD;
+    input[0].U.ki.wVk = virtualKey;
+    input[0].U.ki.dwFlags = down ? 0u : KEYEVENTF_KEYUP;
+    return SendInput(1, input, Marshal.SizeOf(typeof(INPUT))) == 1;
+  }
+
+  public static bool UnicodeText(string text) {
+    foreach (char c in text) {
+      var inputs = new INPUT[2];
+      inputs[0].type = INPUT_KEYBOARD;
+      inputs[0].U.ki.wScan = c;
+      inputs[0].U.ki.dwFlags = KEYEVENTF_UNICODE;
+      inputs[1].type = INPUT_KEYBOARD;
+      inputs[1].U.ki.wScan = c;
+      inputs[1].U.ki.dwFlags = KEYEVENTF_UNICODE | KEYEVENTF_KEYUP;
+      if (SendInput(2, inputs, Marshal.SizeOf(typeof(INPUT))) != 2) return false;
+    }
+    return true;
+  }
+}
+"@
+
+[ChatRelayNative]::SetProcessDPIAware() | Out-Null
+
+function Result-Error([string]$Code) {
+  return [pscustomobject]@{ ok = $false; error = $Code }
+}
+
+function Test-InteractiveSession {
+  return [System.Windows.Forms.SystemInformation]::UserInteractive -and
+    ([ChatRelayNative]::GetForegroundWindow() -ne [IntPtr]::Zero)
+}
+
+function Resolve-Screen($Monitor) {
+  $screens = @([System.Windows.Forms.Screen]::AllScreens)
+  if ($screens.Count -eq 0) { return $null }
+
+  if ($null -eq $Monitor -or [string]$Monitor -eq "primary") {
+    for ($i = 0; $i -lt $screens.Count; $i++) {
+      if ($screens[$i].Primary) {
+        return [pscustomobject]@{ screen = $screens[$i]; index = $i }
+      }
+    }
+    return $null
+  }
+
+  if ([string]$Monitor -eq "secondary") {
+    for ($i = 0; $i -lt $screens.Count; $i++) {
+      if (-not $screens[$i].Primary) {
+        return [pscustomobject]@{ screen = $screens[$i]; index = $i }
+      }
+    }
+    return $null
+  }
+
+  $parsedIndex = 0
+  if (-not [int]::TryParse([string]$Monitor, [ref]$parsedIndex)) { return $null }
+  if ($parsedIndex -lt 0 -or $parsedIndex -ge $screens.Count) { return $null }
+  return [pscustomobject]@{ screen = $screens[$parsedIndex]; index = $parsedIndex }
+}
+
+function Invoke-Screenshot($Payload) {
+  if (-not [System.Windows.Forms.SystemInformation]::UserInteractive) {
+    return Result-Error "session_unavailable"
+  }
+
+  $resolved = Resolve-Screen $Payload.monitor
+  if ($null -eq $resolved) { return Result-Error "monitor_not_found" }
+
+  $screen = $resolved.screen
+  $bounds = $screen.Bounds
+  if ($bounds.Width -le 0 -or $bounds.Height -le 0) {
+    return Result-Error "session_unavailable"
+  }
+
+  $source = $null
+  try {
+    $source = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height
+    $graphics = [System.Drawing.Graphics]::FromImage($source)
+    try {
+      $graphics.CopyFromScreen($bounds.Left, $bounds.Top, 0, 0, $bounds.Size)
+    } finally {
+      $graphics.Dispose()
+    }
+
+    $codec = [System.Drawing.Imaging.ImageCodecInfo]::GetImageEncoders() |
+      Where-Object { $_.MimeType -eq "image/jpeg" } |
+      Select-Object -First 1
+    if ($null -eq $codec) { return Result-Error "capture_failed" }
+
+    $maxBytes = 32768
+    $targetWidth = [Math]::Min($bounds.Width, 960)
+    $targetHeight = [Math]::Max(1, [int][Math]::Round($bounds.Height * ($targetWidth / [double]$bounds.Width)))
+    $qualities = @(58L, 42L, 30L, 22L)
+    $bytes = $null
+    $finalWidth = $targetWidth
+    $finalHeight = $targetHeight
+
+    for ($sizeAttempt = 0; $sizeAttempt -lt 3 -and $null -eq $bytes; $sizeAttempt++) {
+      $resized = New-Object System.Drawing.Bitmap $targetWidth, $targetHeight
+      $draw = [System.Drawing.Graphics]::FromImage($resized)
+      try {
+        $draw.CompositingQuality = [System.Drawing.Drawing2D.CompositingQuality]::HighSpeed
+        $draw.InterpolationMode = [System.Drawing.Drawing2D.InterpolationMode]::Bilinear
+        $draw.PixelOffsetMode = [System.Drawing.Drawing2D.PixelOffsetMode]::HighSpeed
+        $draw.SmoothingMode = [System.Drawing.Drawing2D.SmoothingMode]::HighSpeed
+        $draw.DrawImage($source, 0, 0, $targetWidth, $targetHeight)
+      } finally {
+        $draw.Dispose()
+      }
+
+      try {
+        foreach ($quality in $qualities) {
+          $stream = New-Object System.IO.MemoryStream
+          $parameters = New-Object System.Drawing.Imaging.EncoderParameters 1
+          $parameters.Param[0] = New-Object System.Drawing.Imaging.EncoderParameter(
+            [System.Drawing.Imaging.Encoder]::Quality,
+            $quality
+          )
+          try {
+            $resized.Save($stream, $codec, $parameters)
+            if ($stream.Length -le $maxBytes) {
+              $bytes = $stream.ToArray()
+              $finalWidth = $targetWidth
+              $finalHeight = $targetHeight
+              break
+            }
+          } finally {
+            $parameters.Dispose()
+            $stream.Dispose()
+          }
+        }
+      } finally {
+        $resized.Dispose()
+      }
+
+      if ($null -eq $bytes) {
+        $targetWidth = [Math]::Max(320, [int][Math]::Floor($targetWidth * 0.78))
+        $targetHeight = [Math]::Max(180, [int][Math]::Round($bounds.Height * ($targetWidth / [double]$bounds.Width)))
+      }
+    }
+
+    if ($null -eq $bytes) { return Result-Error "screenshot_too_large" }
+
+    return [pscustomobject]@{
+      ok = $true
+      mimeType = "image/jpeg"
+      data = [Convert]::ToBase64String($bytes)
+      width = $finalWidth
+      height = $finalHeight
+      desktopOriginX = $bounds.Left
+      desktopOriginY = $bounds.Top
+      desktopWidth = $bounds.Width
+      desktopHeight = $bounds.Height
+      scaleX = $bounds.Width / [double]$finalWidth
+      scaleY = $bounds.Height / [double]$finalHeight
+      monitorIndex = $resolved.index
+      isPrimary = [bool]$screen.Primary
+      deviceName = [string]$screen.DeviceName
+      byteLength = $bytes.Length
+    }
+  } catch {
+    return Result-Error "capture_failed"
+  } finally {
+    if ($null -ne $source) { $source.Dispose() }
+  }
+}
+
+function Invoke-MouseClick($Payload) {
+  if (-not (Test-InteractiveSession)) { return Result-Error "session_unavailable" }
+
+  $x = [int]$Payload.x
+  $y = [int]$Payload.y
+  $containsPoint = $false
+  foreach ($screen in @([System.Windows.Forms.Screen]::AllScreens)) {
+    if ($screen.Bounds.Contains($x, $y)) {
+      $containsPoint = $true
+      break
+    }
+  }
+  if (-not $containsPoint) { return Result-Error "invalid_coordinates" }
+
+  switch ([string]$Payload.button) {
+    "left" { $down = 0x0002; $up = 0x0004 }
+    "right" { $down = 0x0008; $up = 0x0010 }
+    "middle" { $down = 0x0020; $up = 0x0040 }
+    default { return Result-Error "invalid_button" }
+  }
+
+  if (-not [ChatRelayNative]::SetCursorPos($x, $y)) { return Result-Error "input_failed" }
+
+  $clicks = [int]$Payload.clicks
+  for ($i = 0; $i -lt $clicks; $i++) {
+    if (-not [ChatRelayNative]::MouseButton($down, $up)) { return Result-Error "input_failed" }
+    if ($i + 1 -lt $clicks) { Start-Sleep -Milliseconds 100 }
+  }
+
+  return [pscustomobject]@{ ok = $true; action = "mouse_click" }
+}
+
+function Invoke-KeyboardInput($Payload) {
+  if (-not (Test-InteractiveSession)) { return Result-Error "session_unavailable" }
+
+  if ($null -ne $Payload.text) {
+    if (-not [ChatRelayNative]::UnicodeText([string]$Payload.text)) {
+      return Result-Error "input_failed"
+    }
+  } else {
+    $mods = New-Object System.Collections.Generic.List[uint16]
+    if ($Payload.ctrl) { $mods.Add(0x11) }
+    if ($Payload.alt) { $mods.Add(0x12) }
+    if ($Payload.shift) { $mods.Add(0x10) }
+    if ($Payload.win) { $mods.Add(0x5B) }
+
+    foreach ($vk in $mods) {
+      if (-not [ChatRelayNative]::Key($vk, $true)) { return Result-Error "input_failed" }
+    }
+
+    try {
+      $keyCode = [uint16]$Payload.keyCode
+      if (-not [ChatRelayNative]::Key($keyCode, $true)) { return Result-Error "input_failed" }
+      if (-not [ChatRelayNative]::Key($keyCode, $false)) { return Result-Error "input_failed" }
+    } finally {
+      for ($i = $mods.Count - 1; $i -ge 0; $i--) {
+        [ChatRelayNative]::Key($mods[$i], $false) | Out-Null
+      }
+    }
+  }
+
+  return [pscustomobject]@{ ok = $true; action = "keyboard_input" }
+}
+
+function Invoke-Step($Payload) {
+  $completed = 0
+  foreach ($action in @($Payload.actions)) {
+    $result = $null
+    switch ([string]$action.type) {
+      "click" { $result = Invoke-MouseClick $action }
+      "text" { $result = Invoke-KeyboardInput $action }
+      "key" { $result = Invoke-KeyboardInput $action }
+      "wait" {
+        Start-Sleep -Milliseconds ([int]$action.ms)
+        $result = [pscustomobject]@{ ok = $true; action = "wait" }
+      }
+      default { $result = Result-Error "invalid_step_action" }
+    }
+
+    if (-not $result.ok) {
+      return [pscustomobject]@{
+        ok = $false
+        error = $result.error
+        actionsCompleted = $completed
+      }
+    }
+    $completed++
+  }
+
+  if ([int]$Payload.settleMs -gt 0) {
+    Start-Sleep -Milliseconds ([int]$Payload.settleMs)
+  }
+
+  if ($Payload.captureAfter -eq $false) {
+    return [pscustomobject]@{
+      ok = $true
+      action = "step"
+      actionsCompleted = $completed
+    }
+  }
+
+  $shotPayload = [pscustomobject]@{ monitor = $Payload.monitor }
+  $shot = Invoke-Screenshot $shotPayload
+  if (-not $shot.ok) {
+    return [pscustomobject]@{
+      ok = $false
+      error = $shot.error
+      actionsCompleted = $completed
+    }
+  }
+
+  $shot | Add-Member -NotePropertyName action -NotePropertyValue "step" -Force
+  $shot | Add-Member -NotePropertyName actionsCompleted -NotePropertyValue $completed -Force
+  return $shot
+}
+
+function Invoke-Operation([string]$Operation, $Payload) {
+  switch ($Operation) {
+    "screenshot" { return Invoke-Screenshot $Payload }
+    "mouse_click" { return Invoke-MouseClick $Payload }
+    "keyboard_input" { return Invoke-KeyboardInput $Payload }
+    "step" { return Invoke-Step $Payload }
+    default { return Result-Error "unknown_desktop_operation" }
+  }
+}
+
+while (($line = [Console]::In.ReadLine()) -ne $null) {
+  if ([string]::IsNullOrWhiteSpace($line)) { continue }
+
+  $id = $null
+  $result = $null
+  try {
+    $request = $line | ConvertFrom-Json
+    $id = [string]$request.id
+    $result = Invoke-Operation ([string]$request.operation) $request.args
+  } catch {
+    $result = Result-Error "desktop_worker_error"
+  }
+
+  $response = [pscustomobject]@{
+    id = $id
+    result = $result
+  }
+
+  [Console]::Out.WriteLine(($response | ConvertTo-Json -Compress -Depth 10))
+  [Console]::Out.Flush()
+}

package/package.json

@@ -1,75 +1,75 @@
 {
-    "name":  "@anusornneal/chat-relay",
-    "version":  "0.7.1",
-    "description":  "Zero-checkout remote MCP agent for ChatGPT with terminal, filesystem, process, multi-user, and multi-agent support.",
-    "type":  "module",
-    "bin":  {
-                "chat-relay":  "bin/chat-relay.js"
-            },
-    "files":  [
-                  "bin/",
-                  "cli/",
-                  "agent/",
-                  "README.md"
-              ],
-    "engines":  {
-                    "node":  "\u003e=20"
-                },
-    "publishConfig":  {
-                          "access":  "public"
-                      },
-    "scripts":  {
-                    "start":  "node bin/chat-relay.js remote",
-                    "remote":  "node bin/chat-relay.js remote",
-                    "login":  "node bin/chat-relay.js login",
-                    "logout":  "node bin/chat-relay.js logout",
-                    "status":  "node bin/chat-relay.js status",
-                    "dev":  "wrangler dev",
-                    "dev:test":  "wrangler dev --local --port 8790 --var AGENT_TOKEN:test-agent --var CALLER_TOKEN=test-caller --var ADMIN_TOKEN=test-admin",
-                    "deploy":  "wrangler deploy",
-                    "agent":  "node --env-file-if-exists=.dev.vars agent/local-agent.mjs",
-                    "admin":  "node scripts/admin.mjs",
-                    "test:terminal":  "node test/mcp-terminal-smoke.mjs",
-                    "test:full":  "node test/multiuser-smoke.mjs",
-                    "test:device-auth":  "node test/device-auth-smoke.mjs",
-                    "test:zero-checkout":  "node test/zero-checkout-smoke.mjs",
-                    "verify:publish":  "npm run verify:review \u0026\u0026 node scripts/verify-publish.mjs \u0026\u0026 npx wrangler deploy --dry-run \u0026\u0026 npm audit --omit=dev",
-                    "prepublishOnly":  "npm run verify:publish",
-                    "test:oauth":  "node test/oauth-smoke.mjs",
-                    "test:usage":  "node test/usage-smoke.mjs",
-                    "test:admin-api":  "node test/admin-api-smoke.mjs",
-                    "test:admin-auth":  "node test/admin-auth-smoke.mjs",
-                    "test:dashboard":  "node test/dashboard-smoke.mjs",
-                    "test:quota":  "node test/quota-smoke.mjs",
-                    "test:ops":  "node test/ops-smoke.mjs",
-                    "test:desktop":  "node test/mcp-desktop-smoke.mjs",
-                    "test:device-management":  "node test/device-management-smoke.mjs",
-                    "test:submission":  "node test/submission-smoke.mjs",
-                    "verify:review":  "node scripts/verify-review-artifacts.mjs"
-                },
-    "dependencies":  {
-                         "ws":  "^8.22.0"
-                     },
-    "devDependencies":  {
-                            "@modelcontextprotocol/server":  "^2.0.0",
-                            "agents":  "^0.24.0",
-                            "wrangler":  "^4.143.0",
-                            "zod":  "^4.6.5"
-                        },
-    "repository":  {
-                       "type":  "git",
-                       "url":  "git+https://github.com/anusornNeal/chat-relay.git"
-                   },
-    "bugs":  {
-                 "url":  "https://github.com/anusornNeal/chat-relay/issues"
-             },
-    "homepage":  "https://github.com/anusornNeal/chat-relay#readme",
-    "keywords":  [
-                     "chatgpt",
-                     "mcp",
-                     "remote-agent",
-                     "terminal",
-                     "cloudflare",
-                     "cli"
-                 ]
+    "name": "@anusornneal/chat-relay",
+    "version": "0.7.2",
+    "description": "Zero-checkout remote MCP agent for ChatGPT with terminal, filesystem, process, multi-user, and multi-agent support.",
+    "type": "module",
+    "bin": {
+        "chat-relay": "bin/chat-relay.js"
+    },
+    "files": [
+        "bin/",
+        "cli/",
+        "agent/",
+        "README.md"
+    ],
+    "engines": {
+        "node": ">=20"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "start": "node bin/chat-relay.js remote",
+        "remote": "node bin/chat-relay.js remote",
+        "login": "node bin/chat-relay.js login",
+        "logout": "node bin/chat-relay.js logout",
+        "status": "node bin/chat-relay.js status",
+        "dev": "wrangler dev",
+        "dev:test": "wrangler dev --local --port 8790 --var AGENT_TOKEN:test-agent --var CALLER_TOKEN=test-caller --var ADMIN_TOKEN=test-admin",
+        "deploy": "wrangler deploy",
+        "agent": "node --env-file-if-exists=.dev.vars agent/local-agent.mjs",
+        "admin": "node scripts/admin.mjs",
+        "test:terminal": "node test/mcp-terminal-smoke.mjs",
+        "test:full": "node test/multiuser-smoke.mjs",
+        "test:device-auth": "node test/device-auth-smoke.mjs",
+        "test:zero-checkout": "node test/zero-checkout-smoke.mjs",
+        "verify:publish": "npm run verify:review && node scripts/verify-publish.mjs && npx wrangler deploy --dry-run && npm audit --omit=dev",
+        "prepublishOnly": "npm run verify:publish",
+        "test:oauth": "node test/oauth-smoke.mjs",
+        "test:usage": "node test/usage-smoke.mjs",
+        "test:admin-api": "node test/admin-api-smoke.mjs",
+        "test:admin-auth": "node test/admin-auth-smoke.mjs",
+        "test:dashboard": "node test/dashboard-smoke.mjs",
+        "test:quota": "node test/quota-smoke.mjs",
+        "test:ops": "node test/ops-smoke.mjs",
+        "test:desktop": "node test/mcp-desktop-smoke.mjs",
+        "test:device-management": "node test/device-management-smoke.mjs",
+        "test:submission": "node test/submission-smoke.mjs",
+        "verify:review": "node scripts/verify-review-artifacts.mjs"
+    },
+    "dependencies": {
+        "ws": "^8.22.0"
+    },
+    "devDependencies": {
+        "@modelcontextprotocol/server": "^2.0.0",
+        "agents": "^0.24.0",
+        "wrangler": "^4.143.0",
+        "zod": "^4.6.5"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/anusornNeal/chat-relay.git"
+    },
+    "bugs": {
+        "url": "https://github.com/anusornNeal/chat-relay/issues"
+    },
+    "homepage": "https://github.com/anusornNeal/chat-relay#readme",
+    "keywords": [
+        "chatgpt",
+        "mcp",
+        "remote-agent",
+        "terminal",
+        "cloudflare",
+        "cli"
+    ]
 }