@xyagent/cli 0.0.1

package/src/tunnel.mjs

@@ -0,0 +1,291 @@
+// `agentlink tunnel <action>` 入口。
+//
+// 顶层只做 dispatcher + 状态文件管理:on / off / ls / agent。
+// 实际代理流量在 tunnel_proxy.mjs;状态/路径/HTTP helper 在 tunnel_state.mjs。
+
+import path from "node:path";
+import process from "node:process";
+
+import { getTunnelRuntimeStatus, startTunnelRuntime, stopTunnelRuntime } from "./tunnel_service.mjs";
+import {
+  TUNNEL_PROTOCOL_HTTP,
+  ensureTunnelStateDir, ensureTunnelLogsDir,
+  tunnelStateDir, tunnelStatePath, resolveTunnelLogPath, resolveAgentlinkHome,
+  readTunnelState, writeTunnelState, safeUnlink, safeReaddir,
+  resolveRelayUrl, resolveRelayOverride,
+  normalizeTunnelProtocol, buildTunnelTargetBaseUrl, parsePort,
+  renderOutput,
+  createTunnelLogger,
+} from "./tunnel_state.mjs";
+import {
+  createTunnel, safeDeleteRemoteTunnel,
+  startTunnelHeartbeat,
+  runHttpAgentLoop, runStreamAgentLoop,
+} from "./tunnel_proxy.mjs";
+
+export async function runTunnelCommand({
+  action, port, relay, protocol, json = false, cliPath, defaultRelayUrl,
+  fail, t = (key) => key, serverToken = "", agentOptions = {},
+}) {
+  const tunnelAction = String(action ?? "").trim().toLowerCase();
+  if (!tunnelAction) {
+    fail(t("tunnel_action_required"));
+  }
+
+  switch (tunnelAction) {
+    case "on":
+      await runTunnelOn({ port, relay, protocol, json, cliPath, defaultRelayUrl, fail, t, serverToken });
+      return;
+    case "off":
+      await runTunnelOff({ port, relay, protocol, json, fail, t });
+      return;
+    case "ls":
+      runTunnelList({ json, t });
+      return;
+    case "agent":
+      await runTunnelAgent({ port, relay, fail, t, agentOptions });
+      return;
+    default:
+      fail(t("tunnel_unknown_action", { action: tunnelAction }));
+  }
+}
+
+async function runTunnelOn({ port, relay, protocol, json, cliPath, defaultRelayUrl, fail, t, serverToken }) {
+  const localPort = parsePort(port, fail);
+  const relayUrl = resolveRelayUrl(relay, defaultRelayUrl, fail);
+  const tunnelProtocol = normalizeTunnelProtocol(protocol, fail);
+  ensureTunnelStateDir();
+  ensureTunnelLogsDir();
+
+  const statePath = tunnelStatePath(localPort);
+  const existing = readTunnelState(statePath);
+  if (existing) {
+    const existingRuntime = getTunnelRuntimeStatus({
+      localPort, runtime: existing.runtime, pid: existing.pid,
+    });
+    if (existingRuntime.running) {
+      renderOutput(json, {
+        status: "ok",
+        action: "on",
+        alreadyRunning: true,
+        port: localPort,
+        protocol: existing.protocol ?? TUNNEL_PROTOCOL_HTTP,
+        publicUrl: existing.publicUrl,
+        relayUrl: existing.relayUrl,
+        remotePort: existing.remotePort ?? null,
+        pid: existingRuntime.pid ?? existing.pid ?? null,
+        manager: existingRuntime.manager ?? existing.runtime?.manager ?? "detached",
+      }, [
+        t("tunnel_already_running", { port: localPort }),
+        `Public: ${existing.publicUrl}`,
+      ]);
+      return;
+    }
+    stopTunnelRuntime({ localPort, runtime: existing.runtime, pid: existing.pid });
+    await safeDeleteRemoteTunnel(existing);
+    safeUnlink(statePath);
+  }
+
+  const targetBaseUrl = buildTunnelTargetBaseUrl(tunnelProtocol, localPort);
+  const created = await createTunnel({
+    relayUrl, localPort, protocol: tunnelProtocol, targetBaseUrl, serverToken, fail,
+  });
+  const logPath = resolveTunnelLogPath(localPort);
+  const state = {
+    id: created.id,
+    slug: created.slug,
+    protocol: created.protocol ?? tunnelProtocol,
+    publicUrl: created.publicUrl,
+    relayUrl,
+    localPort,
+    remotePort: created.remotePort ?? null,
+    targetBaseUrl,
+    token: created.agentToken,
+    pid: null,
+    logPath,
+    createdAt: new Date().toISOString(),
+  };
+
+  let runtime;
+  try {
+    runtime = startTunnelRuntime({
+      localPort, relayUrl, cliPath,
+      tunnelID: created.id,
+      tunnelToken: created.agentToken,
+      slug: created.slug,
+      protocol: state.protocol,
+      targetBaseUrl,
+      logPath,
+      agentlinkHome: resolveAgentlinkHome(),
+    });
+  } catch (error) {
+    await safeDeleteRemoteTunnel(state);
+    fail(String(error instanceof Error ? error.message : error));
+  }
+  state.pid = runtime?.pid ?? null;
+  state.runtime = {
+    mode: runtime?.mode ?? "process",
+    manager: runtime?.manager ?? "detached",
+    target: runtime?.target ?? null,
+    ref: runtime?.ref ?? null,
+    launchScriptPath: runtime?.launchScriptPath ?? null,
+  };
+  writeTunnelState(statePath, state);
+
+  renderOutput(json, {
+    status: "ok",
+    action: "on",
+    port: localPort,
+    protocol: state.protocol,
+    publicUrl: created.publicUrl,
+    relayUrl,
+    remotePort: created.remotePort ?? null,
+    pid: runtime?.pid ?? null,
+    logPath,
+    manager: state.runtime.manager,
+    warning: runtime?.warning ?? null,
+  }, [
+    t("tunnel_started"),
+    `Proto:  ${state.protocol}`,
+    `Local:  ${targetBaseUrl}`,
+    `Public: ${created.publicUrl}`,
+    ...(created.remotePort ? [`Remote: ${created.remotePort}`] : []),
+    `Logs:   ${logPath}`,
+    `Mode:   ${state.runtime.manager}`,
+    ...(runtime?.warning ? [`Note:   ${runtime.warning}`] : []),
+  ]);
+}
+
+async function runTunnelOff({ port, relay, protocol, json, fail, t }) {
+  const localPort = parsePort(port, fail);
+  const requestedProtocol = normalizeTunnelProtocol(protocol, fail, true);
+  const statePath = tunnelStatePath(localPort);
+  const state = readTunnelState(statePath);
+  if (!state) {
+    renderOutput(json, {
+      status: "ok", action: "off",
+      port: localPort, stopped: false,
+      message: "tunnel not found",
+    }, [t("tunnel_not_found", { port: localPort })]);
+    return;
+  }
+  if (requestedProtocol && state.protocol && state.protocol !== requestedProtocol) {
+    fail(t("tunnel_protocol_mismatch", { port: localPort, running: state.protocol, requested: requestedProtocol }));
+  }
+
+  const runtime = stopTunnelRuntime({ localPort, runtime: state.runtime, pid: state.pid });
+  await safeDeleteRemoteTunnel({
+    ...state,
+    relayUrl: resolveRelayOverride(relay, state.relayUrl),
+  });
+  safeUnlink(statePath);
+
+  renderOutput(json, {
+    status: "ok", action: "off",
+    port: localPort,
+    protocol: state.protocol ?? TUNNEL_PROTOCOL_HTTP,
+    stopped: true,
+    manager: runtime?.manager ?? state.runtime?.manager ?? "detached",
+  }, [t("tunnel_stopped", { port: localPort })]);
+}
+
+function runTunnelList({ json, t }) {
+  ensureTunnelStateDir();
+  const entries = [];
+  for (const name of safeReaddir(tunnelStateDir())) {
+    if (!name.endsWith(".json")) continue;
+    const state = readTunnelState(path.join(tunnelStateDir(), name));
+    if (!state) continue;
+    const runtime = getTunnelRuntimeStatus({
+      localPort: state.localPort, runtime: state.runtime, pid: state.pid,
+    });
+    entries.push({
+      port: state.localPort,
+      protocol: state.protocol ?? TUNNEL_PROTOCOL_HTTP,
+      publicUrl: state.publicUrl,
+      remotePort: state.remotePort ?? null,
+      relayUrl: state.relayUrl,
+      pid: state.pid ?? null,
+      manager: runtime.manager,
+      running: runtime.running,
+    });
+  }
+  entries.sort((a, b) => a.port - b.port);
+  if (json) {
+    console.log(JSON.stringify({ status: "ok", tunnels: entries }, null, 2));
+    return;
+  }
+  if (entries.length === 0) {
+    console.log(t("tunnel_no_active_state"));
+    return;
+  }
+  for (const entry of entries) {
+    const remoteText = entry.remotePort ? `\t${entry.remotePort}` : "";
+    console.log(
+      `${entry.port}\t${entry.protocol}\t${entry.running ? "running" : "stopped"}` +
+      `\t${entry.manager}${remoteText}\t${entry.publicUrl}`,
+    );
+  }
+}
+
+async function runTunnelAgent({ port, relay, fail, t, agentOptions }) {
+  const localPort = parsePort(port, fail);
+  const relayUrl = resolveRelayUrl(relay, "", fail);
+  const tunnelID = String(agentOptions.id ?? "").trim();
+  const tunnelToken = String(agentOptions.token ?? "").trim();
+  const protocol = normalizeTunnelProtocol(agentOptions.protocol, fail);
+  const targetBaseUrl =
+    String(agentOptions.target ?? "").trim() ||
+    buildTunnelTargetBaseUrl(protocol, localPort);
+  if (!tunnelID) fail(t("tunnel_missing_agent_id"));
+  if (!tunnelToken) fail(t("tunnel_missing_agent_token"));
+
+  const logger = createTunnelLogger({ localPort, tunnelID, targetBaseUrl, relayUrl });
+  const stopState = { stopping: false };
+  const heartbeat = startTunnelHeartbeat({ relayUrl, tunnelID, tunnelToken, logger });
+
+  logger.info("agent start", {
+    slug: String(agentOptions.slug ?? "").trim() || "-",
+  });
+
+  const requestStop = (reason) => {
+    if (stopState.stopping) return;
+    stopState.stopping = true;
+    heartbeat.stop();
+    logger.info("agent stopping", { reason });
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => requestStop("SIGTERM"));
+  process.on("SIGINT", () => requestStop("SIGINT"));
+
+  try {
+    await heartbeat.sendNow("startup");
+  } catch (error) {
+    logger.error("heartbeat failed", {
+      phase: "startup",
+      error: String(error instanceof Error ? error.message : error),
+    });
+  }
+
+  if (protocol === TUNNEL_PROTOCOL_HTTP) {
+    // publicPathPrefix:tunnel 在 relay 端挂载点(`/t/<slug>`)。被代理的应用
+    // 不知道自己挂在这个前缀下,返回的 HTML/CSS 里 absolute path(`/_next/...`)
+    // 浏览器会以 origin 根开始请求 → 不命中 relay 路由 → 404。
+    // 这里把前缀传给 proxyTunnelRequest,让它在 text/html 响应里改写 absolute
+    // path 加上前缀。slug 缺失时(向后兼容旧 service file)前缀为空,跳过改写。
+    const slug = String(agentOptions.slug ?? "").trim();
+    const publicPathPrefix = slug ? `/t/${slug}` : "";
+    // shim 里的 WebSocket hook 需要知道 ws 公开挂载点 (`/tw/<slug>`),不是
+    // HTTP 那条。relay 端 WS 走的就是 /tw/ 路由 ([http_tunnel.go]
+    // buildPublicTunnelURL),保持一致。
+    const publicWsPathPrefix = slug ? `/tw/${slug}` : "";
+    await runHttpAgentLoop({
+      stopState, relayUrl, tunnelID, tunnelToken, targetBaseUrl, logger,
+      publicPathPrefix, publicWsPathPrefix,
+    });
+    return;
+  }
+  await runStreamAgentLoop({
+    stopState, protocol, relayUrl, tunnelID, tunnelToken, targetBaseUrl, logger,
+  });
+}