agent-anywhere-gateway 0.1.0

package/src/gateway/main.js

@@ -0,0 +1,224 @@
+const {
+  gatewayId,
+  registerMachine,
+  registerUrl,
+  serverWsUrl,
+  startGateway
+} = require("./client");
+
+function parseArgs(argv = process.argv.slice(2)) {
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const readValue = (name) => {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error(`${name} requires a value`);
+      }
+      index += 1;
+      return value;
+    };
+
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else if (arg === "--server" || arg === "--worker-url") {
+      options.server = readValue(arg);
+    } else if (arg === "--server-ws-url") {
+      options.serverWsUrl = readValue(arg);
+    } else if (arg === "--id") {
+      options.id = readValue(arg);
+    } else if (arg === "--name") {
+      options.name = readValue(arg);
+    } else if (arg === "--token") {
+      options.token = readValue(arg);
+    } else if (arg === "--allowed-roots") {
+      options.allowedRoots = readValue(arg);
+    } else if (arg === "--provider") {
+      options.provider = readValue(arg);
+    } else if (arg === "--providers") {
+      options.providers = readValue(arg);
+    } else if (arg === "--data-dir") {
+      options.dataDir = readValue(arg);
+    } else if (arg === "--replay-dir") {
+      options.replayDir = readValue(arg);
+    } else if (arg === "--reconnect-min-ms") {
+      options.reconnectMinMs = readValue(arg);
+    } else if (arg === "--reconnect-max-ms") {
+      options.reconnectMaxMs = readValue(arg);
+    } else if (arg === "--dry-run") {
+      options.dryRun = true;
+    } else {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return options;
+}
+
+function normalizeGatewayId(value) {
+  return String(value || gatewayId())
+    .trim()
+    .replace(/[^A-Za-z0-9_.-]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "gateway";
+}
+
+function toGatewayWsUrl(serverUrl, id) {
+  const url = new URL(serverUrl);
+  if (url.protocol === "http:") {
+    url.protocol = "ws:";
+  } else if (url.protocol === "https:") {
+    url.protocol = "wss:";
+  }
+  if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new Error("--server must be an http(s) or ws(s) URL");
+  }
+  if (!url.pathname || url.pathname === "/") {
+    url.pathname = `/api/gateways/${encodeURIComponent(id)}/ws`;
+  }
+  return url.toString();
+}
+
+function resolveServerWsUrl(env, id) {
+  const raw = env.AGENT_ANYWHERE_SERVER_WS_URL || `ws://localhost:8787/api/gateways/${encodeURIComponent(id)}/ws`;
+  const url = new URL(raw.replace("{gateway_id}", encodeURIComponent(id)));
+  if (!url.searchParams.has("token") && env.AGENT_ANYWHERE_GATEWAY_TOKEN) {
+    url.searchParams.set("token", env.AGENT_ANYWHERE_GATEWAY_TOKEN);
+  }
+  return url.toString();
+}
+
+function applyCliOptions(options = {}, env = process.env) {
+  const id = normalizeGatewayId(options.id || env.AGENT_ANYWHERE_GATEWAY_ID);
+  if (options.id) {
+    env.AGENT_ANYWHERE_GATEWAY_ID = id;
+  }
+  if (options.name) {
+    env.AGENT_ANYWHERE_MACHINE_NAME = options.name;
+  }
+  if (options.token) {
+    env.AGENT_ANYWHERE_GATEWAY_TOKEN = options.token;
+  }
+  if (options.allowedRoots) {
+    env.AGENT_ANYWHERE_ALLOWED_ROOTS = options.allowedRoots;
+  }
+  if (options.providers) {
+    env.AGENT_PROVIDERS = options.providers;
+  }
+  if (options.provider) {
+    if (options.provider.includes(",")) {
+      env.AGENT_PROVIDERS = options.provider;
+    } else {
+      env.AGENT_PROVIDER = options.provider;
+    }
+  }
+  if (options.dataDir) {
+    env.AGENT_ANYWHERE_DATA_DIR = options.dataDir;
+  }
+  if (options.replayDir) {
+    env.AGENT_ANYWHERE_GATEWAY_REPLAY_DIR = options.replayDir;
+  }
+  if (options.reconnectMinMs) {
+    env.AGENT_ANYWHERE_GATEWAY_RECONNECT_MIN_MS = options.reconnectMinMs;
+  }
+  if (options.reconnectMaxMs) {
+    env.AGENT_ANYWHERE_GATEWAY_RECONNECT_MAX_MS = options.reconnectMaxMs;
+  }
+  if (options.serverWsUrl) {
+    env.AGENT_ANYWHERE_SERVER_WS_URL = options.serverWsUrl;
+  } else if (options.server) {
+    env.AGENT_ANYWHERE_SERVER_WS_URL = toGatewayWsUrl(options.server, id);
+  }
+  return {
+    id,
+    name: env.AGENT_ANYWHERE_MACHINE_NAME || id,
+    provider: env.AGENT_PROVIDERS || env.AGENT_ANYWHERE_PROVIDERS || env.AGENT_PROVIDER || "mock",
+    allowedRoots: env.AGENT_ANYWHERE_ALLOWED_ROOTS || "",
+    serverWsUrl: resolveServerWsUrl(env, id),
+    hasToken: Boolean(env.AGENT_ANYWHERE_GATEWAY_TOKEN)
+  };
+}
+
+function helpText() {
+  return [
+    "Usage: agent-anywhere-gateway [options]",
+    "",
+    "Starts an Agent Anywhere Gateway on the controlled machine.",
+    "",
+    "Options:",
+    "  --server <url>             Control Server or Worker URL, http(s) or ws(s)",
+    "  --server-ws-url <url>      Explicit gateway WebSocket URL",
+    "  --id <id>                  Stable gateway machine id",
+    "  --name <name>              Human-readable machine name",
+    "  --token <token>            Shared gateway token",
+    "  --allowed-roots <paths>    Comma-separated allowed project roots",
+    "  --provider <provider>      Local provider, default mock; comma-separated values enable multiple providers",
+    "  --providers <providers>    Comma-separated local providers for one gateway",
+    "  --data-dir <path>          Gateway data directory",
+    "  --replay-dir <path>        Offline stream replay directory",
+    "  --reconnect-min-ms <ms>    Minimum reconnect delay",
+    "  --reconnect-max-ms <ms>    Maximum reconnect delay",
+    "  --dry-run                  Print resolved config and exit",
+    "  --help                     Show this help",
+    "",
+    "Environment:",
+    "  AGENT_ANYWHERE_SERVER_WS_URL Control Server WebSocket URL",
+    "  AGENT_ANYWHERE_GATEWAY_ID    Stable gateway machine id",
+    "  AGENT_ANYWHERE_GATEWAY_TOKEN Shared gateway token",
+    "  AGENT_ANYWHERE_ALLOWED_ROOTS Comma-separated allowed project roots",
+    "  AGENT_PROVIDER               Local provider, default mock",
+    "  AGENT_PROVIDERS              Comma-separated local providers for one gateway"
+  ].join("\n");
+}
+
+function printPlan(plan, log = console.log) {
+  log(`Gateway id: ${plan.id}`);
+  log(`Machine name: ${plan.name}`);
+  log(`Server WS URL: ${plan.serverWsUrl}`);
+  log(`Allowed roots: ${plan.allowedRoots || "(default)"}`);
+  log(`Provider: ${plan.provider}`);
+  log(`Gateway token: ${plan.hasToken ? "(set)" : "(default or missing)"}`);
+}
+
+function runCli(argv = process.argv.slice(2), env = process.env) {
+  const options = parseArgs(argv);
+  if (options.help) {
+    console.log(helpText());
+    return Promise.resolve();
+  }
+  const plan = applyCliOptions(options, env);
+  if (options.dryRun) {
+    printPlan(plan);
+    return Promise.resolve();
+  }
+  return startGateway().catch((error) => {
+    console.error(error.stack || error.message);
+    process.exitCode = 1;
+  });
+}
+
+if (require.main === module) {
+  try {
+    Promise.resolve(runCli()).catch((error) => {
+      console.error(error.stack || error.message);
+      process.exitCode = 1;
+    });
+  } catch (error) {
+    console.error(error.stack || error.message);
+    process.exitCode = 1;
+  }
+}
+
+module.exports = {
+  applyCliOptions,
+  gatewayId,
+  helpText,
+  normalizeGatewayId,
+  parseArgs,
+  printPlan,
+  registerMachine,
+  registerUrl,
+  resolveServerWsUrl,
+  runCli,
+  serverWsUrl,
+  startGateway,
+  toGatewayWsUrl
+};

package/src/gateway/providers.js

@@ -0,0 +1,28 @@
+const { normalizeProviderName, parseProviderList } = require("../shared/providers");
+
+function providerNames(env = process.env) {
+  return parseProviderList(env.AGENT_ANYWHERE_PROVIDERS || env.AGENT_PROVIDERS || env.AGENT_PROVIDER || "mock");
+}
+
+function defaultProviderName(env = process.env) {
+  return providerNames(env)[0] || "mock";
+}
+
+function selectProviderForPayload(payload = {}, env = process.env) {
+  const providers = providerNames(env);
+  const requested = normalizeProviderName(payload.provider || payload.session?.provider || defaultProviderName(env));
+  if (providers.includes(requested)) {
+    return requested;
+  }
+  const error = new Error(`gateway 不支持 provider：${requested}`);
+  error.statusCode = 400;
+  throw error;
+}
+
+module.exports = {
+  defaultProviderName,
+  normalizeProviderName,
+  parseProviderList,
+  providerNames,
+  selectProviderForPayload
+};

package/src/gateway/runner.js

@@ -0,0 +1,337 @@
+const os = require("node:os");
+const path = require("node:path");
+const { createLocalAgentAdapter } = require("../adapters/local-agent-adapter");
+const { buildCapabilities, capabilitiesForProvider, normalizeAgentSettings } = require("../shared/capabilities");
+const { GatewayMessageType, GatewayRequestMethod } = require("../shared/gateway-protocol");
+const { defaultProviderName, selectProviderForPayload } = require("./providers");
+const {
+  imageAttachmentsOnly,
+  materializeImageAttachments,
+  normalizeAttachments
+} = require("../shared/image-attachments");
+const { discoverGitProjects } = require("../lib/local-discovery");
+const { parseAllowedRoots, resolveProjectPath } = require("../shared/path-policy");
+const { readProjectFile } = require("../shared/project-files");
+
+const pendingApprovalDecisions = new Map();
+
+function defaultGatewayId() {
+  return process.env.AGENT_ANYWHERE_GATEWAY_ID || os.hostname() || "gateway";
+}
+
+function providerName() {
+  return defaultProviderName();
+}
+
+function attachmentBaseDir() {
+  return process.env.AGENT_ANYWHERE_DATA_DIR || path.join(process.cwd(), ".data");
+}
+
+function allowedRootPaths() {
+  return parseAllowedRoots(process.env.AGENT_ANYWHERE_ALLOWED_ROOTS);
+}
+
+async function localCapabilities(adapter, provider) {
+  try {
+    return await adapter.discoverCapabilities();
+  } catch {
+    return buildCapabilities(provider);
+  }
+}
+
+async function runRequest(payload, send, { gatewayId = defaultGatewayId() } = {}) {
+  const provider = selectProviderForPayload(payload);
+  const adapter = createLocalAgentAdapter(provider);
+  const projectPath = resolveProjectPath(payload.project_path, allowedRootPaths());
+  const session = { ...(payload.session || { id: "gateway-session" }), provider };
+  const project = { id: "gateway-project", path: projectPath };
+  const capabilities = await localCapabilities(adapter, provider);
+  const settings = normalizeAgentSettings(payload.settings || {}, session, capabilitiesForProvider(provider, capabilities));
+  const normalizedAttachments = normalizeAttachments(payload.attachments || []);
+  const attachments = materializeImageAttachments(imageAttachmentsOnly(normalizedAttachments), {
+    baseDir: attachmentBaseDir(),
+    sessionId: session.id || "gateway-session",
+    turnId: "gateway-turn"
+  });
+
+  for await (const event of adapter.runTurn({
+    machine: { id: gatewayId, host: "" },
+    session,
+    project,
+    message: String(payload.message || ""),
+    attachments,
+    settings,
+    requestApproval: (approvalPayload) => {
+      const approvalRequestId = `approval_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+      send({
+        type: GatewayMessageType.STREAM_EVENT,
+        payload: {
+          type: "approval_request",
+          payload: {
+            ...approvalPayload,
+            gateway_approval_request_id: approvalRequestId
+          }
+        }
+      });
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pendingApprovalDecisions.delete(approvalRequestId);
+          reject(new Error("gateway approval decision timed out"));
+        }, 5 * 60 * 1000);
+        pendingApprovalDecisions.set(approvalRequestId, { resolve, reject, timeout });
+      });
+    }
+  })) {
+    send({
+      type: GatewayMessageType.STREAM_EVENT,
+      payload: event
+    });
+  }
+}
+
+async function controlTurnRequest(payload, action) {
+  const provider = selectProviderForPayload(payload);
+  const adapter = createLocalAgentAdapter(provider);
+  const session = { ...(payload.session || { id: "gateway-session" }), provider };
+  if (action === "cancel") {
+    return adapter.cancelTurn({
+      session,
+      turnId: payload.turn_id,
+      reason: payload.reason
+    });
+  }
+  const normalizedAttachments = normalizeAttachments(payload.attachments || []);
+  return adapter.steerTurn({
+    session,
+    turnId: payload.turn_id,
+    message: String(payload.message || ""),
+    attachments: materializeImageAttachments(imageAttachmentsOnly(normalizedAttachments), {
+      baseDir: attachmentBaseDir(),
+      sessionId: session.id || "gateway-session",
+      turnId: payload.turn_id || "steer"
+    })
+  });
+}
+
+async function listRuntimeSessionsRequest(payload) {
+  const provider = payload.provider ? selectProviderForPayload(payload) : providerName();
+  const adapter = createLocalAgentAdapter(provider);
+  const projectPath = resolveProjectPath(payload.project_path, allowedRootPaths());
+  const sessions = await adapter.listRuntimeSessions({
+    project: { id: "gateway-project", path: projectPath },
+    limit: Number(payload.limit || 50)
+  });
+  return {
+    sessions: await enrichRuntimeSessions(adapter, sessions)
+  };
+}
+
+async function enrichRuntimeSessions(adapter, sessions) {
+  const enriched = [];
+  for (const session of sessions || []) {
+    const runtimeSessionId = runtimeSessionIdOf(session);
+    if (!runtimeSessionId || hasDisplayTitle(session)) {
+      enriched.push(normalizeRuntimeSession(session));
+      continue;
+    }
+    try {
+      const detail = await adapter.readRuntimeSession({
+        runtimeSessionId,
+        includeTurns: true
+      });
+      enriched.push(normalizeRuntimeSession({
+        ...session,
+        ...threadMetadata(detail?.thread),
+        first_user_message: session.first_user_message || firstTurnPrompt(runtimeDetailTurns(detail)),
+        turns: undefined
+      }));
+    } catch {
+      enriched.push(normalizeRuntimeSession(session));
+    }
+  }
+  return enriched;
+}
+
+function runtimeSessionIdOf(session = {}) {
+  return session.runtime_session_id || session.id || session.thread?.id || null;
+}
+
+function hasDisplayTitle(session = {}) {
+  const id = runtimeSessionIdOf(session);
+  const title = displayTitleOf(session);
+  return Boolean(title && title !== id);
+}
+
+function normalizeRuntimeSession(session = {}) {
+  const runtimeSessionId = runtimeSessionIdOf(session);
+  return {
+    ...session,
+    id: session.id || runtimeSessionId,
+    runtime_session_id: runtimeSessionId,
+    title: displayTitleOf(session) || runtimeSessionId,
+    provider: session.provider || providerName()
+  };
+}
+
+function threadMetadata(thread = {}) {
+  return {
+    id: thread.id,
+    runtime_session_id: thread.id,
+    title: displayTitleOf(thread),
+    name: thread.name,
+    preview: thread.preview,
+    first_user_message: thread.first_user_message,
+    model: thread.model,
+    reasoning_effort: thread.reasoning_effort,
+    approval_policy: thread.approval_policy,
+    mode: thread.mode,
+    created_at: thread.created_at || thread.createdAt,
+    updated_at: thread.updated_at || thread.updatedAt
+  };
+}
+
+function displayTitleOf(value = {}) {
+  return value.title || value.name || value.preview || value.first_user_message || value.thread?.title ||
+    value.thread?.name || value.thread?.preview || value.thread?.first_user_message || null;
+}
+
+function firstTurnPrompt(turns) {
+  for (const turn of turns || []) {
+    const prompt = turn?.prompt || turn?.message || turn?.user_message ||
+      textFromInput(turn?.input) || textFromThreadItems(turn?.items);
+    if (prompt) {
+      return String(prompt);
+    }
+  }
+  return null;
+}
+
+function runtimeDetailTurns(detail = {}) {
+  if (Array.isArray(detail.turns)) {
+    return detail.turns;
+  }
+  if (Array.isArray(detail.thread?.turns)) {
+    return detail.thread.turns;
+  }
+  return [];
+}
+
+function textFromInput(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (!Array.isArray(input)) {
+    return input?.text || null;
+  }
+  return input
+    .map((item) => typeof item === "string" ? item : item?.text)
+    .filter(Boolean)
+    .join("\n") || null;
+}
+
+function textFromThreadItems(items) {
+  if (!Array.isArray(items)) {
+    return null;
+  }
+  for (const item of items) {
+    if (item?.type !== "userMessage") {
+      continue;
+    }
+    const text = textFromInput(item.content);
+    if (text) {
+      return text;
+    }
+  }
+  return null;
+}
+
+async function readRuntimeSessionRequest(payload) {
+  const provider = payload.provider ? selectProviderForPayload(payload) : providerName();
+  const adapter = createLocalAgentAdapter(provider);
+  return adapter.readRuntimeSession({
+    runtimeSessionId: payload.runtime_session_id,
+    includeTurns: payload.include_turns !== false
+  });
+}
+
+function discoverProjectsRequest() {
+  return {
+    projects: discoverGitProjects(allowedRootPaths())
+  };
+}
+
+function readProjectFileRequest(payload) {
+  return readProjectFile({
+    projectPath: payload.project_path,
+    requestedPath: payload.path,
+    allowedRoots: allowedRootPaths()
+  });
+}
+
+function handleApprovalDecision(message) {
+  const approval = pendingApprovalDecisions.get(message.approval_request_id);
+  if (!approval) {
+    return false;
+  }
+  clearTimeout(approval.timeout);
+  pendingApprovalDecisions.delete(message.approval_request_id);
+  if (message.error) {
+    approval.reject(new Error(message.error));
+    return true;
+  }
+  approval.resolve(message.payload || {});
+  return true;
+}
+
+async function handleRequest(message, send, options = {}) {
+  try {
+    if (message.method === GatewayRequestMethod.RUN) {
+      await runRequest(message.payload || {}, send, options);
+      send({ type: GatewayMessageType.STREAM_COMPLETE });
+      return;
+    }
+    if (message.method === GatewayRequestMethod.DISCOVER_PROJECTS) {
+      send({ type: GatewayMessageType.RESPONSE, payload: discoverProjectsRequest() });
+      return;
+    }
+    if (message.method === GatewayRequestMethod.CANCEL_TURN) {
+      send({ type: GatewayMessageType.RESPONSE, payload: await controlTurnRequest(message.payload || {}, "cancel") });
+      return;
+    }
+    if (message.method === GatewayRequestMethod.STEER_TURN) {
+      send({ type: GatewayMessageType.RESPONSE, payload: await controlTurnRequest(message.payload || {}, "steer") });
+      return;
+    }
+    if (message.method === GatewayRequestMethod.LIST_RUNTIME_SESSIONS) {
+      send({ type: GatewayMessageType.RESPONSE, payload: await listRuntimeSessionsRequest(message.payload || {}) });
+      return;
+    }
+    if (message.method === GatewayRequestMethod.READ_RUNTIME_SESSION) {
+      send({ type: GatewayMessageType.RESPONSE, payload: await readRuntimeSessionRequest(message.payload || {}) });
+      return;
+    }
+    if (message.method === GatewayRequestMethod.READ_PROJECT_FILE) {
+      send({ type: GatewayMessageType.RESPONSE, payload: readProjectFileRequest(message.payload || {}) });
+      return;
+    }
+    send({ type: GatewayMessageType.ERROR, error: `未知 gateway 方法：${message.method}` });
+  } catch (error) {
+    send({
+      type: message.method === GatewayRequestMethod.RUN ? GatewayMessageType.STREAM_ERROR : GatewayMessageType.ERROR,
+      error: error.message
+    });
+  }
+}
+
+module.exports = {
+  controlTurnRequest,
+  discoverProjectsRequest,
+  enrichRuntimeSessions,
+  handleApprovalDecision,
+  handleRequest,
+  listRuntimeSessionsRequest,
+  runtimeDetailTurns,
+  readProjectFileRequest,
+  readRuntimeSessionRequest,
+  runRequest
+};

package/src/gateway.js

@@ -0,0 +1,7 @@
+const { runCli } = require("./gateway/main");
+
+if (require.main === module) {
+  runCli();
+}
+
+module.exports = require("./gateway/main");

package/src/lib/capabilities.js

@@ -0,0 +1 @@
+module.exports = require("../shared/capabilities");