copilot-proxy-web 1.0.0

package/bin/run-web.js

@@ -0,0 +1,548 @@
+#!/usr/bin/env node
+"use strict";
+
+const path = require("path");
+const os = require("os");
+const fs = require("fs");
+const dns = require("dns");
+const http = require("http");
+const https = require("https");
+const { spawn, spawnSync } = require("child_process");
+const { execSync } = require("child_process");
+const {
+  normalizePath,
+  extractHostname,
+  resolveHostnameWithDomain,
+  inferDomainFromHostname,
+  formatCheckLine,
+  parseRouteCreatedRecord,
+} = require("../lib/cloudflare-utils");
+const { createDaemonStateStore } = require("../lib/daemon-state");
+const { createDaemonService } = require("../lib/daemon-service");
+const { createCloudflareStateStore } = require("../lib/cloudflare-state");
+const { createCloudflareService } = require("../lib/cloudflare-service");
+const { createCloudflareSetupService } = require("../lib/cloudflare-setup-service");
+const { createCloudflareSetupDeps } = require("../lib/cloudflare-setup-deps");
+
+const DEFAULTS = {
+  port: "3000",
+  log: "/tmp/copilot-proxy/",
+  ptyCols: "80",
+  ptyRows: "24",
+  noDefaultSession: true,
+  noStdin: true,
+  noStdout: true,
+};
+
+const argv = process.argv.slice(2);
+let subcommand = "run";
+if (argv.length > 0 && !argv[0].startsWith("-")) {
+  subcommand = argv[0];
+  const allowed = new Set([
+    "run",
+    "start",
+    "stop",
+    "status",
+    "check",
+    "cloudflare",
+    "wc",
+  ]);
+  if (!allowed.has(subcommand)) {
+    console.error(`Unknown subcommand: ${subcommand}`);
+    console.error("Available: run | start | stop | status | check | cloudflare | wc");
+    process.exit(1);
+  }
+  argv.shift();
+}
+
+const passthrough = [];
+const overrides = {
+  port: null,
+  log: null,
+  ptyCols: null,
+  ptyRows: null,
+  noDefaultSession: null,
+  noStdin: null,
+  noStdout: null,
+};
+
+function takeValue(i) {
+  if (i + 1 >= argv.length) {
+    throw new Error(`Missing value for ${argv[i]}`);
+  }
+  return argv[i + 1];
+}
+
+for (let i = 0; i < argv.length; i += 1) {
+  const arg = argv[i];
+
+  if (arg === "--help" || arg === "-h") {
+    console.log(`Usage:
+  npx copilot-proxy-web [run|start|stop|status|check] [overrides] [extra flags]
+  npx copilot-proxy-web cloudflare <setup|start|stop|status|check|diagnose|clean|token> [flags]
+  npx copilot-proxy-web wc [ws client flags]
+
+Overrides:
+  --port <n>           (default: ${DEFAULTS.port})
+  --log <path>         (default: ${DEFAULTS.log})
+  --pty-cols <n>       (default: ${DEFAULTS.ptyCols})
+  --pty-rows <n>       (default: ${DEFAULTS.ptyRows})
+  --auth-token <tok>   (or set AUTH_TOKEN env var)
+  --default-session    (removes --no-default-session)
+  --stdin              (removes --no-stdin)
+  --stdout             (removes --no-stdout)
+
+WS client flags (wc):
+  --url URL              WebSocket endpoint (wss://.../ws)
+  --sessionId ID         Session id to attach
+  --token TOKEN          AUTH_TOKEN (or set AUTH_TOKEN env)
+  --origin ORIGIN        Set Origin header (for servers that require it)
+  --header KEY:VALUE     Add custom request header (repeatable)
+  --cf-access-id ID      Cloudflare Access Client ID
+  --cf-access-secret ID  Cloudflare Access Client Secret
+  --text TEXT            Send a text command (adds CR on server)
+  --keys KEYS            Send raw keys
+  --resize COLSxROWS     Send resize event once
+  --no-stdin             Do not forward stdin
+
+Cloudflare flags:
+  setup --hostname <host>      (required) Tunnel hostname (e.g. proxy.example.com)
+  setup --domain <zone>        (optional) DNS zone guard (e.g. example.com). If omitted, auto-infer from hostname (last two labels).
+  setup --tunnel-name <name>   (default: copilot-proxy-web)
+  setup --port <n>             (default: ${DEFAULTS.port})
+  setup --service <http|https> (override scheme for localhost target)
+  setup --service-url <url>    (override full service target, e.g. https://127.0.0.1:3000/health)
+  setup --path <path>          (match on hostname + path, e.g. /path01)
+  token set --token <TOKEN>
+  status/diagnose --local-url <url>   (override local health check URL)
+  status/diagnose --local-path <path> (override local path; builds http://127.0.0.1:<port><path>)
+`);
+    process.exit(0);
+  }
+
+  if (arg === "--port") {
+    overrides.port = takeValue(i);
+    i += 1;
+    continue;
+  }
+  if (arg === "--log") {
+    overrides.log = takeValue(i);
+    i += 1;
+    continue;
+  }
+  if (arg === "--pty-cols") {
+    overrides.ptyCols = takeValue(i);
+    i += 1;
+    continue;
+  }
+  if (arg === "--pty-rows") {
+    overrides.ptyRows = takeValue(i);
+    i += 1;
+    continue;
+  }
+
+  if (arg === "--default-session") {
+    overrides.noDefaultSession = false;
+    continue;
+  }
+  if (arg === "--no-default-session") {
+    overrides.noDefaultSession = true;
+    continue;
+  }
+  if (arg === "--stdin") {
+    overrides.noStdin = false;
+    continue;
+  }
+  if (arg === "--no-stdin") {
+    overrides.noStdin = true;
+    continue;
+  }
+  if (arg === "--stdout") {
+    overrides.noStdout = false;
+    continue;
+  }
+  if (arg === "--no-stdout") {
+    overrides.noStdout = true;
+    continue;
+  }
+
+  passthrough.push(arg);
+}
+
+const port = overrides.port ?? DEFAULTS.port;
+const log = overrides.log ?? DEFAULTS.log;
+const ptyCols = overrides.ptyCols ?? DEFAULTS.ptyCols;
+const ptyRows = overrides.ptyRows ?? DEFAULTS.ptyRows;
+const noDefaultSession =
+  overrides.noDefaultSession ?? DEFAULTS.noDefaultSession;
+const noStdin = overrides.noStdin ?? DEFAULTS.noStdin;
+const noStdout = overrides.noStdout ?? DEFAULTS.noStdout;
+
+function getPassthroughValue(flag) {
+  const idx = passthrough.indexOf(flag);
+  if (idx >= 0 && idx + 1 < passthrough.length) {
+    return passthrough[idx + 1];
+  }
+  return null;
+}
+
+function hasAuthConfigured() {
+  if (process.env.AUTH_TOKEN) return true;
+  return Boolean(getPassthroughValue("--auth-token"));
+}
+
+function resolveHostForPrint() {
+  return getPassthroughValue("--host") || "127.0.0.1";
+}
+
+function resolveApiPortForPrint() {
+  return getPassthroughValue("--api-port") || port;
+}
+
+function getCloudflareArg(flag) {
+  const actions = new Set([
+    "setup",
+    "start",
+    "stop",
+    "status",
+    "check",
+    "diagnose",
+    "clean",
+    "token",
+  ]);
+  let start = 0;
+  if (argv.length > 0 && actions.has(argv[0])) start = 1;
+  for (let i = start; i < argv.length; i += 1) {
+    if (argv[i] === flag && i + 1 < argv.length) return argv[i + 1];
+  }
+  return null;
+}
+
+const homeRoot =
+  process.env.COPILOT_PROXY_HOME || path.join(os.homedir(), ".copilot-proxy-web");
+const pidFile = path.join(homeRoot, "proxy.pid");
+const stateFile = path.join(homeRoot, "state.json");
+const cfRoot = path.join(homeRoot, "cloudflare");
+const cfPidFile = path.join(cfRoot, "cloudflared.pid");
+const cfStateFile = path.join(cfRoot, "state.json");
+const cfConfigFile = path.join(cfRoot, "config.yml");
+const cfTokenFile = path.join(cfRoot, "token.txt");
+const daemonStateStore = createDaemonStateStore({
+  fs,
+  homeRoot,
+  pidFile,
+  stateFile,
+});
+const cfStateStore = createCloudflareStateStore({
+  fs,
+  paths: {
+    cfRoot,
+    cfPidFile,
+    cfStateFile,
+    cfConfigFile,
+    cfTokenFile,
+  },
+});
+
+function isProcessAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sleep(ms) {
+  const shared = new Int32Array(new SharedArrayBuffer(4));
+  Atomics.wait(shared, 0, 0, ms);
+}
+
+function buildArgs() {
+  const args = [
+    path.join(__dirname, "..", "copilot-proxy.js"),
+    "--web",
+    "--port",
+    port,
+    "--shell",
+    "--log",
+    log,
+    "--pty-cols",
+    ptyCols,
+    "--pty-rows",
+    ptyRows,
+  ];
+
+  if (noDefaultSession) args.push("--no-default-session");
+  if (noStdin) args.push("--no-stdin");
+  if (noStdout) args.push("--no-stdout");
+
+  args.push(...passthrough);
+  return args;
+}
+
+function restoreTerminal() {
+  if (process.stdin.isTTY) {
+    try {
+      process.stdin.setRawMode(false);
+    } catch {
+      // ignore
+    }
+    if (process.platform !== "win32") {
+      try {
+        execSync("stty sane", { stdio: "inherit" });
+      } catch {
+        // ignore
+      }
+    }
+  }
+}
+
+function runForeground() {
+  return daemonService.runForeground();
+}
+
+function startBackground() {
+  return daemonService.startBackground();
+}
+
+function stopBackground() {
+  return daemonService.stopBackground();
+}
+
+function status() {
+  return daemonService.status();
+}
+
+function check() {
+  return daemonService.check();
+}
+
+function findInPath(bin) {
+  const pathEnv = process.env.PATH || "";
+  const parts = pathEnv.split(path.delimiter);
+  for (const dir of parts) {
+    if (!dir) continue;
+    const candidate = path.join(dir, bin);
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      return candidate;
+    } catch {
+      // continue
+    }
+  }
+  return null;
+}
+
+function resolveCloudflaredBin() {
+  const envBin = process.env.CLOUDFLARED_BIN;
+  if (envBin) return envBin;
+  const inPath = findInPath("cloudflared");
+  if (inPath) return inPath;
+  const common = ["/opt/homebrew/bin/cloudflared", "/usr/local/bin/cloudflared", "/usr/bin/cloudflared"];
+  for (const candidate of common) {
+    try {
+      fs.accessSync(candidate, fs.constants.X_OK);
+      return candidate;
+    } catch {
+      // continue
+    }
+  }
+  return "cloudflared";
+}
+
+function ensureCloudflaredOrExit() {
+  const bin = resolveCloudflaredBin();
+  const res = spawnSync(bin, ["--version"], { stdio: "ignore" });
+  if (res.error) {
+    console.error("cloudflared not found.");
+    console.error("Install:");
+    console.error("  https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflare-tunnel/downloads/");
+    console.error("  https://github.com/cloudflare/cloudflared");
+    console.error("Or set CLOUDFLARED_BIN=/full/path/to/cloudflared");
+    process.exit(1);
+  }
+  return bin;
+}
+
+const daemonService = createDaemonService({
+  daemonStateStore,
+  buildArgs,
+  spawnFn: spawn,
+  isProcessAlive,
+  sleepFn: sleep,
+  processLike: process,
+  consoleLike: console,
+  httpLike: http,
+  resolveHostForPrint,
+  resolveApiPortForPrint,
+  hasAuthConfigured,
+  port,
+  log,
+  ptyCols,
+  ptyRows,
+  noDefaultSession,
+  noStdin,
+  noStdout,
+  passthrough,
+  restoreTerminal,
+});
+
+const cloudflareSetupDeps = createCloudflareSetupDeps({
+  fs,
+  path,
+  os,
+  dns,
+  spawnSync,
+  cfRoot,
+  cfConfigFile,
+});
+
+const cloudflareSetupService = createCloudflareSetupService({
+  extractHostname,
+  inferDomainFromHostname,
+  resolveHostnameWithDomain,
+  ensureCloudflaredOrExit,
+  port,
+  cfStateStore,
+  resolveTunnelId: cloudflareSetupDeps.resolveTunnelId,
+  findCredentialsForTunnel: cloudflareSetupDeps.findCredentialsForTunnel,
+  readLatestCredentialsFile: cloudflareSetupDeps.readLatestCredentialsFile,
+  hasOriginCert: cloudflareSetupDeps.hasOriginCert,
+  lookupDnsAddresses: cloudflareSetupDeps.lookupDnsAddresses,
+  findDnsRouteLine: cloudflareSetupDeps.findDnsRouteLine,
+  writeCloudflareConfigWithService: cloudflareSetupDeps.writeCloudflareConfigWithService,
+  parseRouteCreatedRecord,
+  spawnFn: spawn,
+  consoleLike: console,
+  processLike: process,
+  formatCheckLine,
+  cfConfigFile,
+});
+
+const cloudflareService = createCloudflareService({
+  ensureCloudflaredOrExit,
+  cfStateStore,
+  cfConfigFile,
+  cfTokenFile,
+  fsLike: fs,
+  spawnFn: spawn,
+  isProcessAlive,
+  sleepFn: sleep,
+  processLike: process,
+  consoleLike: console,
+  httpsLike: https,
+  httpLike: http,
+  getCloudflareArg,
+  normalizePath,
+  port,
+});
+
+function cloudflareSetup(cfArgs) {
+  return cloudflareSetupService.cloudflareSetup(cfArgs);
+}
+
+function cloudflareStart() {
+  return cloudflareService.cloudflareStart();
+}
+
+function cloudflareStop() {
+  return cloudflareService.cloudflareStop();
+}
+
+function cloudflareStatus() {
+  return cloudflareService.cloudflareStatus();
+}
+
+function cloudflareCheck() {
+  return cloudflareService.cloudflareCheck();
+}
+
+function cloudflareDiagnose() {
+  return cloudflareService.cloudflareDiagnose();
+}
+
+function cloudflareClean() {
+  return cloudflareService.cloudflareClean();
+}
+
+function cloudflareToken(action, tokenValue) {
+  return cloudflareService.cloudflareToken(action, tokenValue);
+}
+
+function runWsClient() {
+  const clientPath = path.join(__dirname, "wss-client.js");
+  const res = spawnSync(process.execPath, [clientPath, ...argv], {
+    stdio: "inherit",
+  });
+  if (res.error) {
+    console.error(res.error?.message || "Failed to start WS client.");
+    process.exit(1);
+  }
+  process.exit(res.status ?? 0);
+}
+
+if (subcommand === "run") {
+  runForeground();
+} else if (subcommand === "start") {
+  startBackground();
+} else if (subcommand === "stop") {
+  stopBackground();
+} else if (subcommand === "status") {
+  status();
+} else if (subcommand === "check") {
+  check();
+} else if (subcommand === "cloudflare") {
+  const action = argv[0];
+  if (action === "--help" || action === "-h") {
+    console.log(`Usage:
+  npx copilot-proxy-web cloudflare <setup|start|stop|status|check|diagnose|clean|token> [flags]
+
+Setup:
+  --hostname <host>      (required) Tunnel hostname (e.g. proxy.example.com)
+  --domain <zone>        (optional) DNS zone guard (e.g. example.com). If omitted, auto-infer from hostname (last two labels).
+  --tunnel-name <name>   (default: copilot-proxy-web)
+  --port <n>             (default: ${port})
+
+Token:
+  cloudflare token set --token <TOKEN>
+  cloudflare token get
+  cloudflare token clear
+`);
+    process.exit(0);
+  }
+  const cfArgs = argv.slice(1);
+  if (!action) {
+    console.error("Usage: npx copilot-proxy-web cloudflare <setup|start|stop|status|check>");
+    process.exit(1);
+  }
+  if (action === "setup") {
+    cloudflareSetup(cfArgs);
+  } else if (action === "start") {
+    cloudflareStart();
+  } else if (action === "stop") {
+    cloudflareStop();
+  } else if (action === "status") {
+    cloudflareStatus();
+  } else if (action === "check") {
+    cloudflareCheck();
+  } else if (action === "diagnose") {
+    cloudflareDiagnose();
+  } else if (action === "clean") {
+    cloudflareClean();
+  } else if (action === "token") {
+    const tokenAction = cfArgs[0];
+    let tokenValue = null;
+    const tokenIdx = cfArgs.indexOf("--token");
+    if (tokenIdx >= 0 && tokenIdx + 1 < cfArgs.length) {
+      tokenValue = cfArgs[tokenIdx + 1];
+    }
+    cloudflareToken(tokenAction, tokenValue);
+  } else {
+    console.error(`Unknown cloudflare command: ${action}`);
+    process.exit(1);
+  }
+} else if (subcommand === "wc") {
+  runWsClient();
+}