agent-anywhere-gateway 0.1.0

package/src/shared/project-files.js

@@ -0,0 +1,119 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { isInside, resolveProjectPath } = require("./path-policy");
+
+const MAX_PROJECT_FILE_BYTES = 20 * 1024 * 1024;
+
+const PROJECT_FILE_MIME_TYPES = Object.freeze({
+  ".csv": "text/csv; charset=utf-8",
+  ".doc": "application/msword",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".gif": "image/gif",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".json": "application/json; charset=utf-8",
+  ".log": "text/plain; charset=utf-8",
+  ".markdown": "text/markdown; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".txt": "text/plain; charset=utf-8",
+  ".webp": "image/webp"
+});
+
+function httpError(message, statusCode) {
+  const error = new Error(message);
+  error.statusCode = statusCode;
+  return error;
+}
+
+function cleanRequestedPath(rawPath) {
+  let value = String(rawPath || "").trim();
+  if (!value) {
+    throw httpError("文件路径不能为空。", 400);
+  }
+  if (value.startsWith("file://")) {
+    try {
+      value = new URL(value).pathname;
+    } catch {
+      throw httpError("文件路径无效。", 400);
+    }
+  }
+  value = value.replace(/^["'`<]+|["'`>]+$/g, "");
+  try {
+    value = decodeURIComponent(value);
+  } catch {
+    // 已经是普通路径时保留原值。
+  }
+  return stripLineReference(value);
+}
+
+function stripLineReference(filePath) {
+  const extensions = Object.keys(PROJECT_FILE_MIME_TYPES)
+    .map((extension) => extension.slice(1).replace(".", "\\."))
+    .join("|");
+  return String(filePath || "").replace(new RegExp(`\\.(${extensions})(?::\\d+(?::\\d+)?)?$`, "i"), ".$1");
+}
+
+function supportedProjectFileMimeType(filePath) {
+  return PROJECT_FILE_MIME_TYPES[path.extname(filePath).toLowerCase()] || null;
+}
+
+function resolveProjectFilePath({ projectPath, requestedPath, allowedRoots }) {
+  const projectRoot = resolveProjectPath(projectPath, allowedRoots);
+  const cleaned = cleanRequestedPath(requestedPath);
+  const targetPath = path.isAbsolute(cleaned) || cleaned.startsWith("~")
+    ? cleaned
+    : path.join(projectRoot, cleaned);
+  const resolved = resolveProjectPath(targetPath, allowedRoots);
+  if (!isInside(resolved, projectRoot)) {
+    throw httpError("只能打开当前项目目录内的文件。", 403);
+  }
+  return { projectRoot, resolved };
+}
+
+function assertRealFileInsideProject(filePath, projectRoot) {
+  if (!fs.existsSync(filePath)) {
+    throw httpError("文件不存在。", 404);
+  }
+  const stat = fs.statSync(filePath);
+  if (!stat.isFile()) {
+    throw httpError("目标路径不是文件。", 400);
+  }
+  const realProjectRoot = fs.realpathSync.native(projectRoot);
+  const realFilePath = fs.realpathSync.native(filePath);
+  if (!isInside(realFilePath, realProjectRoot)) {
+    throw httpError("只能打开当前项目目录内的文件。", 403);
+  }
+  if (stat.size > MAX_PROJECT_FILE_BYTES) {
+    throw httpError("文件过大，无法在浏览器中打开。", 413);
+  }
+  return stat;
+}
+
+function readProjectFile({ projectPath, requestedPath, allowedRoots }) {
+  const { projectRoot, resolved } = resolveProjectFilePath({ projectPath, requestedPath, allowedRoots });
+  const mimeType = supportedProjectFileMimeType(resolved);
+  if (!mimeType) {
+    throw httpError("只支持打开常见文档和图片文件。", 415);
+  }
+  const stat = assertRealFileInsideProject(resolved, projectRoot);
+  return {
+    name: path.basename(resolved),
+    path: resolved,
+    mime_type: mimeType,
+    size: stat.size,
+    encoding: "base64",
+    content: fs.readFileSync(resolved).toString("base64")
+  };
+}
+
+module.exports = {
+  MAX_PROJECT_FILE_BYTES,
+  PROJECT_FILE_MIME_TYPES,
+  cleanRequestedPath,
+  readProjectFile,
+  resolveProjectFilePath,
+  stripLineReference,
+  supportedProjectFileMimeType
+};

package/src/shared/providers.js

@@ -0,0 +1,27 @@
+const PROVIDER_ALIASES = {
+  claude: "claude-code"
+};
+
+function normalizeProviderName(provider) {
+  const name = String(provider || "").trim();
+  return PROVIDER_ALIASES[name] || name;
+}
+
+function parseProviderList(value, fallback = ["mock"]) {
+  const providers = String(value || "")
+    .split(",")
+    .map(normalizeProviderName)
+    .filter(Boolean);
+  const unique = [];
+  for (const provider of providers) {
+    if (!unique.includes(provider)) {
+      unique.push(provider);
+    }
+  }
+  return unique.length ? unique : fallback;
+}
+
+module.exports = {
+  normalizeProviderName,
+  parseProviderList
+};

package/src/shared/runtime-environment.js

@@ -0,0 +1,32 @@
+function envFlagDisabled(value) {
+  return ["0", "false", "no", "off", "disabled"].includes(String(value || "").trim().toLowerCase());
+}
+
+function supportsLocalRuntime({
+  env = typeof process !== "undefined" ? process.env : {},
+  platform = typeof process !== "undefined" ? process.platform : "",
+  hasProcess = typeof process !== "undefined"
+} = {}) {
+  if (!hasProcess) {
+    return false;
+  }
+  if (envFlagDisabled(env.AGENT_ANYWHERE_LOCAL_RUNTIME)) {
+    return false;
+  }
+  if (env.AGENT_ANYWHERE_DEPLOYMENT_TARGET === "cloudflare-workers") {
+    return false;
+  }
+  return Boolean(platform);
+}
+
+function runtimeSupport(options = {}) {
+  return {
+    local_runtime: supportsLocalRuntime(options),
+    gateway_runtime: true
+  };
+}
+
+module.exports = {
+  runtimeSupport,
+  supportsLocalRuntime
+};

package/src/shared/websocket.js

@@ -0,0 +1,258 @@
+const crypto = require("node:crypto");
+const { EventEmitter } = require("node:events");
+const net = require("node:net");
+const tls = require("node:tls");
+
+const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+
+function acceptKey(key) {
+  return crypto
+    .createHash("sha1")
+    .update(`${key}${WS_GUID}`)
+    .digest("base64");
+}
+
+function encodeFrame(text) {
+  const payload = Buffer.from(text, "utf8");
+  const header = [];
+  header.push(0x81);
+  if (payload.length < 126) {
+    header.push(payload.length);
+  } else if (payload.length <= 0xffff) {
+    header.push(126, (payload.length >> 8) & 0xff, payload.length & 0xff);
+  } else {
+    header.push(127, 0, 0, 0, 0);
+    header.push(
+      (payload.length >> 24) & 0xff,
+      (payload.length >> 16) & 0xff,
+      (payload.length >> 8) & 0xff,
+      payload.length & 0xff
+    );
+  }
+  return Buffer.concat([Buffer.from(header), payload]);
+}
+
+function decodeFrames(buffer) {
+  const messages = [];
+  let offset = 0;
+  let close = false;
+  const controlFrames = [];
+
+  while (buffer.length - offset >= 2) {
+    const first = buffer[offset];
+    const second = buffer[offset + 1];
+    const opcode = first & 0x0f;
+    const masked = Boolean(second & 0x80);
+    let payloadLength = second & 0x7f;
+    let headerLength = 2;
+
+    if (payloadLength === 126) {
+      if (buffer.length - offset < 4) {
+        break;
+      }
+      payloadLength = buffer.readUInt16BE(offset + 2);
+      headerLength = 4;
+    } else if (payloadLength === 127) {
+      if (buffer.length - offset < 10) {
+        break;
+      }
+      const high = buffer.readUInt32BE(offset + 2);
+      const low = buffer.readUInt32BE(offset + 6);
+      payloadLength = high * 2 ** 32 + low;
+      headerLength = 10;
+    }
+
+    const maskLength = masked ? 4 : 0;
+    const frameLength = headerLength + maskLength + payloadLength;
+    if (buffer.length - offset < frameLength) {
+      break;
+    }
+
+    const maskOffset = offset + headerLength;
+    const payloadOffset = maskOffset + maskLength;
+    const payload = Buffer.from(buffer.subarray(payloadOffset, payloadOffset + payloadLength));
+    if (masked) {
+      const mask = buffer.subarray(maskOffset, maskOffset + 4);
+      for (let index = 0; index < payload.length; index += 1) {
+        payload[index] ^= mask[index % 4];
+      }
+    }
+
+    if (opcode === 0x1) {
+      messages.push(payload.toString("utf8"));
+    } else if (opcode === 0x8) {
+      close = true;
+    } else if (opcode === 0x9) {
+      controlFrames.push({ opcode: 0x0a, payload });
+    }
+
+    offset += frameLength;
+  }
+
+  return {
+    messages,
+    remaining: buffer.subarray(offset),
+    close,
+    controlFrames
+  };
+}
+
+function encodeControlFrame(opcode, payload = Buffer.alloc(0)) {
+  return Buffer.concat([Buffer.from([0x80 | opcode, payload.length]), payload]);
+}
+
+class WebSocketPeer extends EventEmitter {
+  constructor(socket, initialBuffer = Buffer.alloc(0)) {
+    super();
+    this.socket = socket;
+    this.buffer = Buffer.alloc(0);
+    this.closed = false;
+
+    socket.on("data", (chunk) => this.handleData(chunk));
+    socket.on("close", () => this.closeFromSocket());
+    socket.on("error", (error) => this.emit("error", error));
+    if (initialBuffer.length > 0) {
+      this.handleData(initialBuffer);
+    }
+  }
+
+  handleData(chunk) {
+    this.buffer = Buffer.concat([this.buffer, chunk]);
+    const decoded = decodeFrames(this.buffer);
+    this.buffer = decoded.remaining;
+
+    for (const controlFrame of decoded.controlFrames) {
+      this.socket.write(encodeControlFrame(controlFrame.opcode, controlFrame.payload));
+    }
+    for (const message of decoded.messages) {
+      this.emit("message", message);
+    }
+    if (decoded.close) {
+      this.close();
+    }
+  }
+
+  sendJson(payload) {
+    this.send(JSON.stringify(payload));
+  }
+
+  send(text) {
+    if (this.closed || this.socket.destroyed) {
+      return;
+    }
+    this.socket.write(encodeFrame(text));
+  }
+
+  close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    if (!this.socket.destroyed) {
+      this.socket.end(encodeControlFrame(0x8));
+    }
+    this.emit("close");
+  }
+
+  closeFromSocket() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    this.emit("close");
+  }
+}
+
+function upgradeToWebSocket(req, socket) {
+  const key = req.headers["sec-websocket-key"];
+  if (!key) {
+    socket.destroy();
+    return null;
+  }
+
+  socket.write([
+    "HTTP/1.1 101 Switching Protocols",
+    "Upgrade: websocket",
+    "Connection: Upgrade",
+    `Sec-WebSocket-Accept: ${acceptKey(key)}`,
+    "\r\n"
+  ].join("\r\n"));
+
+  return new WebSocketPeer(socket);
+}
+
+function rejectUpgrade(socket, statusCode, message) {
+  socket.write(`HTTP/1.1 ${statusCode} ${message}\r\nConnection: close\r\n\r\n`);
+  socket.destroy();
+}
+
+function connectWebSocket(urlInput) {
+  const url = new URL(urlInput);
+  const secure = url.protocol === "wss:";
+  const port = Number(url.port || (secure ? 443 : 80));
+  const key = crypto.randomBytes(16).toString("base64");
+  const socket = secure
+    ? tls.connect({ host: url.hostname, port, servername: url.hostname })
+    : net.connect({ host: url.hostname, port });
+
+  return new Promise((resolve, reject) => {
+    let buffer = Buffer.alloc(0);
+    const cleanup = () => {
+      socket.off("data", onData);
+      socket.off("error", onError);
+      socket.off("close", onClose);
+    };
+    const onError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error("websocket closed before handshake completed"));
+    };
+    const onData = (chunk) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      const headerEnd = buffer.indexOf("\r\n\r\n");
+      if (headerEnd < 0) {
+        return;
+      }
+
+      const header = buffer.subarray(0, headerEnd).toString("utf8");
+      const rest = buffer.subarray(headerEnd + 4);
+      if (!/^HTTP\/1\.1 101\b/.test(header)) {
+        cleanup();
+        socket.destroy();
+        reject(new Error(`websocket upgrade failed: ${header.split(/\r?\n/)[0]}`));
+        return;
+      }
+
+      cleanup();
+      resolve(new WebSocketPeer(socket, rest));
+    };
+
+    socket.on("data", onData);
+    socket.on("error", onError);
+    socket.on("close", onClose);
+    socket.on(secure ? "secureConnect" : "connect", () => {
+      const path = `${url.pathname}${url.search}`;
+      socket.write([
+        `GET ${path} HTTP/1.1`,
+        `Host: ${url.host}`,
+        "Upgrade: websocket",
+        "Connection: Upgrade",
+        "Sec-WebSocket-Version: 13",
+        `Sec-WebSocket-Key: ${key}`,
+        "\r\n"
+      ].join("\r\n"));
+    });
+  });
+}
+
+module.exports = {
+  WebSocketPeer,
+  connectWebSocket,
+  decodeFrames,
+  encodeFrame,
+  rejectUpgrade,
+  upgradeToWebSocket
+};