@frontendxlab/opencode-computer-use 0.1.0

package/lib/json-line-peer.mjs

@@ -0,0 +1,182 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import process from "node:process";
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_FRAME_BYTES = 32 * 1024 * 1024;
+
+function safeNativeErrorMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message
+    .replace(/\b(token|secret|password|api[_-]?key|authorization)\s*[:=]\s*(?:bearer|basic)?[^\n\r,;]*/giu, "$1=[redacted]")
+    .slice(0, 4_000);
+}
+
+export class JsonLinePeer extends EventEmitter {
+  constructor({ command, args = [], cwd, env = process.env, child } = {}) {
+    super();
+    this.child = child ?? spawn(command, args, {
+      cwd,
+      env,
+      shell: false,
+      detached: process.platform !== "win32",
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    this.pid = this.child.pid;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.buffer = "";
+    this.stderr = "";
+    this.closed = false;
+    this.exited = false;
+    this.terminationStarted = false;
+    this.exitPromise = new Promise((resolve) => { this.resolveExit = resolve; });
+    this.child.stdout.setEncoding("utf8");
+    this.child.stderr.setEncoding("utf8");
+    this.child.stdout.on("data", (chunk) => this.#onData(chunk));
+    this.child.stderr.on("data", (chunk) => { this.stderr = (this.stderr + chunk).slice(-8192); });
+    this.child.once("error", (error) => this.#close(error, true));
+    this.child.once("exit", (code, signal) => {
+      this.exited = true;
+      this.resolveExit();
+      const detail = this.stderr ? `: ${safeNativeErrorMessage(new Error(this.stderr.trim()))}` : "";
+      this.#close(new Error(`native MCP exited (code=${code ?? "null"}, signal=${signal ?? "null"})${detail}`));
+    });
+    this.child.once("close", () => {
+      if (!this.exited) {
+        this.exited = true;
+        this.resolveExit();
+      }
+    });
+  }
+
+  #onData(chunk) {
+    this.buffer += chunk;
+    if (Buffer.byteLength(this.buffer, "utf8") > MAX_FRAME_BYTES) {
+      this.#close(new Error("native MCP response buffer exceeded limit"), true);
+      return;
+    }
+    for (;;) {
+      const newline = this.buffer.indexOf("\n");
+      if (newline < 0) break;
+      const line = this.buffer.slice(0, newline).trim();
+      this.buffer = this.buffer.slice(newline + 1);
+      if (!line) continue;
+      let message;
+      try {
+        message = JSON.parse(line);
+      } catch {
+        this.#close(new Error(`invalid native MCP JSON: ${line.slice(0, 200)}`), true);
+        return;
+      }
+      if (!message || typeof message !== "object" || Array.isArray(message)) {
+        this.#close(new Error("invalid native MCP message"), true);
+        return;
+      }
+      if (message.id !== undefined && this.pending.has(String(message.id))) {
+        const pending = this.pending.get(String(message.id));
+        this.pending.delete(String(message.id));
+        clearTimeout(pending.timer);
+        if (message.error) {
+          const messageText = typeof message.error?.message === "string" ? message.error.message : JSON.stringify(message.error);
+          pending.reject(new Error(safeNativeErrorMessage(new Error(messageText))));
+        } else {
+          pending.resolve(message.result);
+        }
+      } else {
+        this.emit("message", message);
+      }
+    }
+  }
+
+  #close(error, terminate = false) {
+    if (!this.closed) {
+      this.closed = true;
+      for (const pending of this.pending.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(error);
+      }
+      this.pending.clear();
+      this.emit("close", error);
+    }
+    if (terminate) void this.#terminateChild();
+  }
+
+  #killChild(force) {
+    const signal = force ? "SIGKILL" : "SIGTERM";
+    if (process.platform === "win32") {
+      if (force && this.pid) {
+        try {
+          const killer = spawn("taskkill", ["/PID", String(this.pid), "/T", "/F"], {
+            shell: false,
+            windowsHide: true,
+            stdio: "ignore",
+          });
+          killer.unref();
+        } catch {
+          // Fall through to the direct child termination below.
+        }
+      } else {
+        try { this.child.kill("SIGTERM"); } catch {}
+      }
+      return;
+    }
+    if (this.pid) {
+      try {
+        process.kill(-this.pid, signal);
+        return;
+      } catch {
+        // Fall through to the direct child termination below.
+      }
+    }
+    if (!this.exited) {
+      try { this.child.kill(signal); } catch {}
+    }
+  }
+
+  #terminateChild() {
+    if (this.terminationStarted) return this.exitPromise;
+    this.terminationStarted = true;
+    try { this.child.stdin.end(); } catch {}
+    this.#killChild(false);
+    const timer = setTimeout(() => this.#killChild(true), 1_000);
+    timer.unref();
+    return this.exitPromise.finally(() => clearTimeout(timer));
+  }
+
+  request(method, params = {}, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    if (this.closed) return Promise.reject(new Error("native MCP is closed"));
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs > 0
+        ? setTimeout(() => { this.pending.delete(String(id)); reject(new Error(`native MCP ${method} timed out after ${timeoutMs} ms`)); }, timeoutMs)
+        : undefined;
+      this.pending.set(String(id), { resolve, reject, timer });
+      this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}\n`, (error) => {
+        if (!error) return;
+        if (timer) clearTimeout(timer);
+        this.pending.delete(String(id));
+        reject(error);
+      });
+    });
+  }
+
+  notify(method, params = {}) {
+    if (!this.closed) this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}\n`);
+  }
+
+  async initialize() {
+    const result = await this.request("initialize", {
+      protocolVersion: "2025-06-18",
+      capabilities: {},
+      clientInfo: { name: "open-computer-use-node-repl", version: "1" },
+    });
+    this.notify("notifications/initialized", {});
+    return result;
+  }
+
+  async close() {
+    await this.#terminateChild();
+  }
+}

package/lib/options.js

@@ -0,0 +1,111 @@
+const BACKENDS = new Set(["auto", "native", "custom"]);
+const DEFAULT_SERVER_NAME = "cua_repl";
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringOption(value, fallback) {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+
+function booleanOption(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+function boundedNumber(value, fallback, minimum, maximum) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(maximum, Math.max(minimum, Math.round(value)));
+}
+
+function commandOption(value) {
+  if (!Array.isArray(value) || value.length === 0) return undefined;
+  if (value.some((item) => typeof item !== "string" || !item)) return undefined;
+  return [...value];
+}
+
+function serverNameOption(value) {
+  const name = stringOption(value, DEFAULT_SERVER_NAME);
+  if (!/^[A-Za-z0-9_-]{1,64}$/.test(name)) {
+    throw new Error("serverName must contain only letters, numbers, underscores, or hyphens");
+  }
+  return name;
+}
+
+export function normalizeOptions(input = {}) {
+  const raw = isRecord(input) ? input : {};
+  const backend = stringOption(raw.backend, "auto");
+  if (!BACKENDS.has(backend)) {
+    throw new Error(`backend must be one of: ${[...BACKENDS].join(", ")}`);
+  }
+
+  const command = commandOption(raw.command);
+  if (backend === "custom" && !command) {
+    throw new Error("backend 'custom' requires a non-empty command array");
+  }
+
+  return {
+    backend,
+    command,
+    disabled: booleanOption(raw.disabled, false),
+    allowGlobalPointerFallbacks: booleanOption(raw.allowGlobalPointerFallbacks, false),
+    override: booleanOption(raw.override, false),
+    serverName: serverNameOption(raw.serverName),
+    timeoutMs: boundedNumber(raw.timeoutMs, 30_000, 1_000, 300_000),
+    maxTextChars: boundedNumber(raw.maxTextChars, 200_000, 1_000, 2_000_000),
+    maxImageBytes: boundedNumber(raw.maxImageBytes, 2 * 1024 * 1024, 16_384, 16 * 1024 * 1024),
+  };
+}
+
+export function optionsToEnvironment(options) {
+  const normalized = normalizeOptions(options);
+  const environment = {
+    OPENCODE_COMPUTER_USE_BACKEND: normalized.backend,
+    OPENCODE_COMPUTER_USE_SERVER_NAME: normalized.serverName,
+    OPENCODE_COMPUTER_USE_TIMEOUT_MS: String(normalized.timeoutMs),
+    OPENCODE_COMPUTER_USE_MAX_TEXT_CHARS: String(normalized.maxTextChars),
+    OPENCODE_COMPUTER_USE_MAX_IMAGE_BYTES: String(normalized.maxImageBytes),
+  };
+
+  if (normalized.command) {
+    environment.OPENCODE_COMPUTER_USE_COMMAND = JSON.stringify(normalized.command);
+  }
+  if (normalized.allowGlobalPointerFallbacks) {
+    environment.OPEN_COMPUTER_USE_ALLOW_GLOBAL_POINTER_FALLBACKS = "1";
+  }
+
+  return environment;
+}
+
+export function optionsFromEnvironment(environment = process.env) {
+  const commandText = environment.OPENCODE_COMPUTER_USE_COMMAND;
+  let command;
+  if (commandText) {
+    try {
+      command = commandOption(JSON.parse(commandText));
+    } catch {
+      command = undefined;
+    }
+  }
+
+  return normalizeOptions({
+    backend: environment.OPENCODE_COMPUTER_USE_BACKEND,
+    command,
+    allowGlobalPointerFallbacks: environment.OPEN_COMPUTER_USE_ALLOW_GLOBAL_POINTER_FALLBACKS === "1",
+    serverName: environment.OPENCODE_COMPUTER_USE_SERVER_NAME,
+    timeoutMs: Number(environment.OPENCODE_COMPUTER_USE_TIMEOUT_MS),
+    maxTextChars: Number(environment.OPENCODE_COMPUTER_USE_MAX_TEXT_CHARS),
+    maxImageBytes: Number(environment.OPENCODE_COMPUTER_USE_MAX_IMAGE_BYTES),
+  });
+}
+
+export const defaults = Object.freeze({
+  backend: "auto",
+  disabled: false,
+  allowGlobalPointerFallbacks: false,
+  override: false,
+  serverName: DEFAULT_SERVER_NAME,
+  timeoutMs: 30_000,
+  maxTextChars: 200_000,
+  maxImageBytes: 2 * 1024 * 1024,
+});

package/lib/output.mjs

@@ -0,0 +1,212 @@
+import { inspect } from "node:util";
+
+export const DEFAULT_MAX_TEXT_CHARS = 200_000;
+export const DEFAULT_MAX_IMAGE_BYTES = 2 * 1024 * 1024;
+const MAX_CONTENT_ITEMS = 128;
+const MAX_META_ID_CHARS = 128;
+const MAX_IMAGE_INPUT_BYTES = 16 * 1024 * 1024;
+
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function formatValue(value) {
+  if (typeof value === "string") return value;
+  return inspect(value, { depth: 6, colors: false, breakLength: 100 });
+}
+
+function sniffMimeType(bytes) {
+  if (bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]))) return "image/png";
+  if (bytes.length >= 3 && bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff) return "image/jpeg";
+  if (bytes.length >= 12 && bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP") return "image/webp";
+  throw new Error("nodeRepl.emitImage could not infer PNG, JPEG, or WebP MIME type");
+}
+
+const IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/webp"]);
+
+function decodeImageBase64(value) {
+  if (typeof value !== "string" || value.length === 0 || value.length > Math.ceil(MAX_IMAGE_INPUT_BYTES * 4 / 3) + 4 || value.length % 4 === 1 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(value)) {
+    throw new Error("nodeRepl.emitImage expected valid base64 image data");
+  }
+  const bytes = Buffer.from(value, "base64");
+  const normalizedInput = value.replace(/=+$/u, "");
+  const normalizedOutput = bytes.toString("base64").replace(/=+$/u, "");
+  if (normalizedInput !== normalizedOutput) throw new Error("nodeRepl.emitImage expected canonical base64 image data");
+  return bytes;
+}
+
+function validateImage(mimeType, bytes) {
+  if (bytes.length > MAX_IMAGE_INPUT_BYTES) throw new Error("nodeRepl.emitImage image exceeds the 16 MiB input limit");
+  const normalizedMime = typeof mimeType === "string" ? mimeType.toLowerCase() : "";
+  if (!IMAGE_MIME_TYPES.has(normalizedMime) || sniffMimeType(bytes) !== normalizedMime) {
+    throw new Error("nodeRepl.emitImage expected a PNG, JPEG, or WebP image");
+  }
+  return normalizedMime;
+}
+
+function isArrayBuffer(value) {
+  return value instanceof ArrayBuffer || Object.prototype.toString.call(value) === "[object ArrayBuffer]";
+}
+
+export function normalizeImage(value) {
+  let bytes;
+  let mimeType;
+  if (typeof value === "string") {
+    if (!value.startsWith("data:image/")) throw new Error("nodeRepl.emitImage accepts image data URLs or bytes");
+    const match = /^data:([^;,]+);base64,(.*)$/s.exec(value);
+    if (!match) throw new Error("nodeRepl.emitImage expected a base64 image data URL");
+    mimeType = match[1];
+    bytes = decodeImageBase64(match[2]);
+  } else if (Buffer.isBuffer(value) || isArrayBuffer(value) || ArrayBuffer.isView(value)) {
+    const byteLength = value.byteLength;
+    if (byteLength > MAX_IMAGE_INPUT_BYTES) throw new Error("nodeRepl.emitImage image exceeds the 16 MiB input limit");
+    bytes = Buffer.isBuffer(value)
+      ? value
+      : isArrayBuffer(value)
+        ? Buffer.from(value)
+        : Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+    mimeType = sniffMimeType(bytes);
+  } else if (isPlainObject(value) && value.bytes !== undefined) {
+    const rawBytes = value.bytes;
+    const byteLength = typeof rawBytes === "string" ? rawBytes.length : rawBytes?.byteLength;
+    if (Number.isFinite(byteLength) && byteLength > MAX_IMAGE_INPUT_BYTES) {
+      throw new Error("nodeRepl.emitImage image exceeds the 16 MiB input limit");
+    }
+    bytes = Buffer.from(rawBytes);
+    mimeType = typeof value.mimeType === "string" ? value.mimeType : sniffMimeType(bytes);
+  } else {
+    throw new Error("nodeRepl.emitImage received an unsupported value");
+  }
+  mimeType = validateImage(mimeType, bytes);
+  return { mimeType, data: bytes.toString("base64"), bytes };
+}
+
+export function normalizeNativeImage(image) {
+  return normalizeImage({ bytes: decodeImageBase64(image.data), mimeType: image.mimeType });
+}
+
+export function outputLimits(limits = {}) {
+  const maxTextChars = Number.isFinite(limits.maxTextChars)
+    ? Math.min(Math.max(Math.floor(limits.maxTextChars), 1_000), 2_000_000)
+    : DEFAULT_MAX_TEXT_CHARS;
+  const maxImageBytes = Number.isFinite(limits.maxImageBytes)
+    ? Math.min(Math.max(Math.floor(limits.maxImageBytes), 16_384), 16 * 1024 * 1024)
+    : DEFAULT_MAX_IMAGE_BYTES;
+  return { maxTextChars, maxImageBytes };
+}
+
+export function createOutputCollector(limits) {
+  const { maxTextChars, maxImageBytes } = outputLimits(limits);
+  const content = [];
+  let textChars = 0;
+  let imageBytes = 0;
+  let truncationAdded = false;
+  const truncationMarker = "[output truncated]";
+
+  function markTruncated() {
+    if (truncationAdded) return;
+    const last = content.at(-1);
+    if (last?.type !== "text" || last.text.length < truncationMarker.length) return;
+    const previousLength = last.text.length;
+    last.text = `${last.text.slice(0, -truncationMarker.length)}${truncationMarker}`;
+    textChars = textChars - previousLength + last.text.length;
+    truncationAdded = true;
+  }
+
+  function appendText(value, itemId) {
+    if (content.length >= MAX_CONTENT_ITEMS) {
+      markTruncated();
+      return;
+    }
+    let text = formatValue(value);
+    const remaining = maxTextChars - textChars;
+    if (remaining <= 0) {
+      markTruncated();
+      return;
+    }
+    if (text.length > remaining) {
+      const marker = remaining >= truncationMarker.length ? truncationMarker : "";
+      text = `${text.slice(0, Math.max(0, remaining - marker.length))}${marker}`;
+      truncationAdded = Boolean(marker);
+    }
+    if (!text) return;
+    const item = { type: "text", text };
+    if (typeof itemId === "string" || typeof itemId === "number") {
+      item._meta = { id: String(itemId).slice(0, MAX_META_ID_CHARS) };
+    }
+    content.push(item);
+    textChars += text.length;
+  }
+
+  async function appendImage(value) {
+    if (content.length >= MAX_CONTENT_ITEMS) {
+      appendText("[image omitted because the content item limit was reached]");
+      return;
+    }
+    const image = normalizeImage(await value);
+    if (imageBytes + image.bytes.length > maxImageBytes) {
+      appendText("[image omitted because it exceeded the configured size limit]");
+      return;
+    }
+    if (content.length >= MAX_CONTENT_ITEMS) {
+      appendText("[image omitted because the content item limit was reached]");
+      return;
+    }
+    content.push({ type: "image", mimeType: image.mimeType, data: image.data });
+    imageBytes += image.bytes.length;
+  }
+
+  return { content, write: appendText, emitImage: appendImage };
+}
+
+export function boundToolResult(result, limits) {
+  const { maxTextChars, maxImageBytes } = outputLimits(limits);
+  const content = [];
+  let textChars = 0;
+  let imageBytes = 0;
+  const truncationMarker = "[output truncated]";
+  const imageMarker = "[image omitted because it exceeded the configured size limit]";
+
+  function appendText(text, metadata) {
+    if (content.length >= MAX_CONTENT_ITEMS) return;
+    const remaining = maxTextChars - textChars;
+    if (remaining <= 0) return;
+    let bounded = text;
+    if (bounded.length > remaining) {
+      const marker = remaining >= truncationMarker.length ? truncationMarker : "";
+      bounded = `${bounded.slice(0, Math.max(0, remaining - marker.length))}${marker}`;
+    }
+    if (!bounded) return;
+    const item = { type: "text", text: bounded };
+    if (metadata && typeof metadata.id === "string") {
+      item._meta = { id: metadata.id.slice(0, MAX_META_ID_CHARS) };
+    }
+    content.push(item);
+    textChars += bounded.length;
+  }
+
+  for (const item of result?.content ?? []) {
+    if (content.length >= MAX_CONTENT_ITEMS) break;
+    if (item?.type === "text" && typeof item.text === "string") {
+      appendText(item.text, item._meta);
+      continue;
+    }
+    if (item?.type !== "image" || typeof item.data !== "string") continue;
+    const estimatedBytes = Math.floor(item.data.length * 3 / 4);
+    if (imageBytes + estimatedBytes > maxImageBytes) {
+      appendText(imageMarker);
+      continue;
+    }
+    if (content.length >= MAX_CONTENT_ITEMS) {
+      appendText(imageMarker);
+      continue;
+    }
+    content.push({
+      type: "image",
+      mimeType: typeof item.mimeType === "string" ? item.mimeType : "image/png",
+      data: item.data,
+    });
+    imageBytes += estimatedBytes;
+  }
+  return { ...result, content };
+}

package/lib/repl-kernel.mjs

@@ -0,0 +1,41 @@
+import { parentPort, workerData } from "node:worker_threads";
+import { PersistentJavaScriptSession } from "./repl.mjs";
+
+let nextNativeId = 1;
+let activeTimeoutMs;
+let activeRequestId;
+const pendingNative = new Map();
+const native = {
+  request(method, params, timeoutMs = activeTimeoutMs) {
+    const id = nextNativeId++;
+    return new Promise((resolve, reject) => {
+      pendingNative.set(id, { resolve, reject });
+      parentPort.postMessage({ type: "native_request", id, method, params, timeoutMs, requestId: activeRequestId });
+    });
+  },
+};
+const session = new PersistentJavaScriptSession({ native, limits: workerData });
+
+parentPort.on("message", async message => {
+  if (message.type === "native_response") {
+    const pending = pendingNative.get(message.id);
+    if (!pending) return;
+    pendingNative.delete(message.id);
+    if (message.error) pending.reject(new Error(message.error));
+    else pending.resolve(message.result);
+    return;
+  }
+  if (message.type === "exec") {
+    let result;
+    activeRequestId = message.id;
+    try {
+      activeTimeoutMs = message.timeoutMs;
+      result = await session.run(message.code, 0, message.requestMeta);
+    } catch (error) {
+      result = { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+    }
+    activeTimeoutMs = undefined;
+    activeRequestId = undefined;
+    parentPort.postMessage({ type: "result", id: message.id, result });
+  }
+});