copilot-proxy-web 1.0.0

package/lib/cli.js

@@ -0,0 +1,273 @@
+function parseArgs(argv) {
+  let logPath = "run.log";
+  let webEnabled = false;
+  let webPlain = false;
+  let apiEnabled = false;
+  let host = "127.0.0.1";
+  let port = 3000;
+  let apiPort = 3000;
+  let useShell = false;
+  let debugWs = false;
+  let debugWsPath = "";
+  let ptyCols = 80;
+  let ptyRows = 24;
+  let idleMs = 5000;
+  let idleLogPath = "";
+  let idleClean = true;
+  let idleMarkdown = false;
+  let idleMarkdownMaxChars = 0;
+  let idleBufferMaxChars = null;
+  let idleBurstMs = null;
+  let idlePacketMaxBytes = null;
+  let conversationContext = null;
+  let conversationProfile = null;
+  let authToken = null;
+  let useXForwardedFor = false;
+  let enforceAuthOnPublic = false;
+  let tgToken = null;
+  let tgChat = null;
+  let tgProxy = null;
+  let tgParseMode = null;
+  let tgRetry = null;
+  let tgBackoffMs = null;
+  let tgTimeoutMs = null;
+  let tgMaxChars = null;
+  let cleaned = [];
+  let noDefaultSession = false;
+  let noStdin = false;
+  let noStdout = false;
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--log" && i + 1 < argv.length) {
+      logPath = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === "--web") {
+      webEnabled = true;
+      apiEnabled = true;
+      continue;
+    }
+    if (arg === "--api") {
+      apiEnabled = true;
+      continue;
+    }
+    if (arg === "--web-plain") {
+      webPlain = true;
+      continue;
+    }
+    if (arg === "--debug-ws") {
+      debugWs = true;
+      if (i + 1 < argv.length && !argv[i + 1].startsWith("--")) {
+        debugWsPath = argv[i + 1];
+        i += 1;
+      }
+      continue;
+    }
+    if (arg === "--pty-cols" && i + 1 < argv.length) {
+      ptyCols = Number(argv[i + 1]) || ptyCols;
+      i += 1;
+      continue;
+    }
+    if (arg === "--pty-rows" && i + 1 < argv.length) {
+      ptyRows = Number(argv[i + 1]) || ptyRows;
+      i += 1;
+      continue;
+    }
+    if (arg === "--idle-ms" && i + 1 < argv.length) {
+      const value = Number(argv[i + 1]);
+      if (Number.isFinite(value)) idleMs = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--idle-seconds" && i + 1 < argv.length) {
+      const value = Number(argv[i + 1]);
+      if (Number.isFinite(value)) idleMs = Math.max(0, value * 1000);
+      i += 1;
+      continue;
+    }
+    if (arg === "--idle-log" && i + 1 < argv.length) {
+      idleLogPath = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === "--idle-markdown") {
+      idleMarkdown = true;
+      continue;
+    }
+    if (arg === "--idle-markdown-max" && i + 1 < argv.length) {
+      idleMarkdownMaxChars = Number(argv[i + 1]) || idleMarkdownMaxChars;
+      i += 1;
+      continue;
+    }
+    if (arg === "--idle-buffer-max" && i + 1 < argv.length) {
+      const value = Number(argv[i + 1]);
+      if (Number.isFinite(value)) idleBufferMaxChars = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--idle-burst-ms" && i + 1 < argv.length) {
+      const value = Number(argv[i + 1]);
+      if (Number.isFinite(value)) idleBurstMs = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--idle-packet-max" && i + 1 < argv.length) {
+      const value = Number(argv[i + 1]);
+      if (Number.isFinite(value)) idlePacketMaxBytes = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--conversation-context" && i + 1 < argv.length) {
+      const value = Number(argv[i + 1]);
+      if (Number.isFinite(value)) conversationContext = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--conversation-profile" && i + 1 < argv.length) {
+      conversationProfile = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === "--tg-token" && i + 1 < argv.length) {
+      tgToken = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === "--tg-chat" && i + 1 < argv.length) {
+      tgChat = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === "--tg-proxy" && i + 1 < argv.length) {
+      tgProxy = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === "--tg-parse-mode" && i + 1 < argv.length) {
+      tgParseMode = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === "--tg-retry" && i + 1 < argv.length) {
+      tgRetry = Number(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (arg === "--tg-backoff-ms" && i + 1 < argv.length) {
+      tgBackoffMs = Number(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (arg === "--tg-timeout-ms" && i + 1 < argv.length) {
+      tgTimeoutMs = Number(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (arg === "--tg-max-chars" && i + 1 < argv.length) {
+      tgMaxChars = Number(argv[i + 1]);
+      i += 1;
+      continue;
+    }
+    if (arg === "--auth-token" && i + 1 < argv.length) {
+      authToken = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === "--use-x-forwarded-for") {
+      useXForwardedFor = true;
+      continue;
+    }
+    if (arg === "--enforce-auth-on-public") {
+      enforceAuthOnPublic = true;
+      continue;
+    }
+    if (arg === "--idle-raw") {
+      idleClean = false;
+      continue;
+    }
+    if (arg === "--port" && i + 1 < argv.length) {
+      port = Number(argv[i + 1]) || port;
+      apiPort = port;
+      i += 1;
+      continue;
+    }
+    if (arg === "--host" && i + 1 < argv.length) {
+      host = argv[i + 1];
+      i += 1;
+      continue;
+    }
+    if (arg === "--api-port" && i + 1 < argv.length) {
+      apiPort = Number(argv[i + 1]) || apiPort;
+      i += 1;
+      continue;
+    }
+    if (arg === "--shell") {
+      useShell = true;
+      continue;
+    }
+    if (arg === "--no-default-session") {
+      noDefaultSession = true;
+      continue;
+    }
+    if (arg === "--no-stdin") {
+      noStdin = true;
+      continue;
+    }
+    if (arg === "--no-stdout") {
+      noStdout = true;
+      continue;
+    }
+    cleaned.push(arg);
+  }
+
+  const sepIndex = cleaned.indexOf("--");
+  const cmdArgs = sepIndex >= 0 ? cleaned.slice(sepIndex + 1) : cleaned;
+  const [cmd, ...args] = cmdArgs.length > 0 ? cmdArgs : ["copilot"];
+
+  return {
+    logPath,
+    webEnabled,
+    webPlain,
+    apiEnabled,
+    host,
+    port,
+    apiPort,
+    useShell,
+    debugWs,
+    debugWsPath,
+    ptyCols,
+    ptyRows,
+    idleMs,
+    idleLogPath,
+    idleClean,
+    idleMarkdown,
+    idleMarkdownMaxChars,
+    idleBufferMaxChars,
+    idleBurstMs,
+    idlePacketMaxBytes,
+    conversationContext,
+    conversationProfile,
+    tgToken,
+    tgChat,
+    tgProxy,
+    tgParseMode,
+    tgRetry,
+    tgBackoffMs,
+    tgTimeoutMs,
+    tgMaxChars,
+    authToken,
+    useXForwardedFor,
+    enforceAuthOnPublic,
+    noDefaultSession,
+    noStdin,
+    noStdout,
+    cmd,
+    args,
+  };
+}
+
+module.exports = {
+  parseArgs,
+};

package/lib/cloudflare-service.js

@@ -0,0 +1,326 @@
+function createCloudflareService({
+  ensureCloudflaredOrExit,
+  cfStateStore,
+  cfConfigFile,
+  fsLike,
+  spawnFn,
+  isProcessAlive,
+  sleepFn,
+  processLike,
+  consoleLike,
+  httpsLike,
+  httpLike,
+  getCloudflareArg,
+  normalizePath,
+  port,
+  cfTokenFile,
+}) {
+  function exit(code) {
+    processLike.exit(code);
+  }
+
+  function cloudflareStart() {
+    const bin = ensureCloudflaredOrExit();
+    const existingPid = cfStateStore.readCfPid();
+    if (existingPid && isProcessAlive(existingPid)) {
+      consoleLike.log(`Cloudflare tunnel already running (pid ${existingPid}).`);
+      return exit(0);
+    }
+    if (!fsLike.existsSync(cfConfigFile)) {
+      consoleLike.error("Missing cloudflare config. Run: npx copilot-proxy-web cloudflare setup");
+      return exit(1);
+    }
+    const state = cfStateStore.readCfState();
+    let tokenValue = null;
+    if (state?.tokenFile && fsLike.existsSync(state.tokenFile)) {
+      try {
+        tokenValue = fsLike.readFileSync(state.tokenFile, "utf8").trim();
+      } catch {
+        tokenValue = null;
+      }
+    }
+    const args = tokenValue
+      ? ["tunnel", "run", "--token", tokenValue]
+      : ["tunnel", "--config", cfConfigFile, "run"];
+    const child = spawnFn(bin, args, {
+      stdio: "ignore",
+      detached: true,
+    });
+    child.unref();
+    cfStateStore.writeCfPid(child.pid);
+    consoleLike.log(`Cloudflare tunnel started (pid ${child.pid}).`);
+    return undefined;
+  }
+
+  function cloudflareStop() {
+    const pid = cfStateStore.readCfPid();
+    if (!pid) {
+      consoleLike.log("Cloudflare tunnel not running.");
+      return exit(0);
+    }
+    if (!isProcessAlive(pid)) {
+      cfStateStore.clearCfPid();
+      consoleLike.log("Cloudflare tunnel not running.");
+      return exit(0);
+    }
+    try {
+      processLike.kill(pid, "SIGTERM");
+    } catch {
+      cfStateStore.clearCfPid();
+      consoleLike.error("Failed to stop Cloudflare tunnel.");
+      return exit(1);
+    }
+    for (let i = 0; i < 20; i += 1) {
+      if (!isProcessAlive(pid)) break;
+      sleepFn(100);
+    }
+    if (isProcessAlive(pid)) {
+      try {
+        processLike.kill(pid, "SIGKILL");
+      } catch {
+        // ignore
+      }
+    }
+    cfStateStore.clearCfPid();
+    consoleLike.log("Cloudflare tunnel stopped.");
+    return undefined;
+  }
+
+  function cloudflareStatus({ diagnose } = {}) {
+    const pid = cfStateStore.readCfPid();
+    const state = cfStateStore.readCfState();
+    const warnings = [];
+    const tokenActive = Boolean(state?.tokenFile && fsLike.existsSync(state.tokenFile));
+    if (!tokenActive && state?.credentialsFile) {
+      if (!fsLike.existsSync(state.credentialsFile)) {
+        warnings.push(`credentials missing: ${state.credentialsFile}`);
+      }
+      if (state?.tunnelId) {
+        const expected = `${state.tunnelId}.json`;
+        if (!state.credentialsFile.endsWith(expected)) {
+          warnings.push(`credentials mismatch: expected ${expected}`);
+          warnings.push("open Zero Trust → Networks → Connectors → (tunnel) and copy the token/run command");
+          warnings.push("then run: npx copilot-proxy-web cloudflare token set --token <TOKEN>");
+          warnings.push("docs: https://developers.cloudflare.com/cloudflare-one/");
+        }
+      }
+    }
+    if (pid && isProcessAlive(pid)) {
+      consoleLike.log(`Cloudflare tunnel running (pid ${pid}).`);
+      if (state?.tunnelName) consoleLike.log(`  tunnel name: ${state.tunnelName}`);
+      if (state?.tunnelId) consoleLike.log(`  tunnel id: ${state.tunnelId}`);
+      if (state?.hostname) consoleLike.log(`  hostname: ${state.hostname}`);
+      if (state?.localPort) consoleLike.log(`  local port: ${state.localPort}`);
+      if (state?.configFile) consoleLike.log(`  config: ${state.configFile}`);
+      if (tokenActive) {
+        consoleLike.log(`  token: ${state.tokenFile}`);
+        consoleLike.log("  token mode: active (credentials ignored)");
+      } else if (state?.credentialsFile) {
+        consoleLike.log(`  credentials: ${state.credentialsFile}`);
+      }
+      for (const warning of warnings) {
+        consoleLike.log(`  warning: ${warning}`);
+      }
+      if (state?.hostname) {
+        const diagnoseFn = diagnose || cloudflareDiagnose;
+        diagnoseFn();
+        return undefined;
+      }
+      return exit(0);
+    }
+    consoleLike.log("Cloudflare tunnel stopped.");
+    if (state?.tunnelName) consoleLike.log(`  tunnel name: ${state.tunnelName}`);
+    if (state?.tunnelId) consoleLike.log(`  tunnel id: ${state.tunnelId}`);
+    if (state?.hostname) consoleLike.log(`  hostname: ${state.hostname}`);
+    if (state?.localPort) consoleLike.log(`  local port: ${state.localPort}`);
+    if (state?.configFile) consoleLike.log(`  config: ${state.configFile}`);
+    if (tokenActive) {
+      consoleLike.log(`  token: ${state.tokenFile}`);
+      consoleLike.log("  token mode: active (credentials ignored)");
+    } else if (state?.credentialsFile) {
+      consoleLike.log(`  credentials: ${state.credentialsFile}`);
+    }
+    for (const warning of warnings) {
+      consoleLike.log(`  warning: ${warning}`);
+    }
+    return exit(1);
+  }
+
+  function cloudflareCheck() {
+    const state = cfStateStore.readCfState();
+    if (!state?.hostname) {
+      consoleLike.error("Missing hostname in Cloudflare state. Run setup first.");
+      return exit(1);
+    }
+    const url = `https://${state.hostname}/api/sessions`;
+    const req = httpsLike.get(
+      url,
+      { timeout: 5000 },
+      (res) => {
+        res.resume();
+        if (res.statusCode < 500) {
+          consoleLike.log(`OK (${url})`);
+          exit(0);
+          return;
+        }
+        consoleLike.error(`Unhealthy (HTTP ${res.statusCode})`);
+        exit(1);
+      }
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      consoleLike.error("Unhealthy (timeout)");
+      exit(1);
+    });
+    req.on("error", () => {
+      consoleLike.error("Unhealthy (connection failed)");
+      exit(1);
+    });
+    return undefined;
+  }
+
+  function cloudflareDiagnose() {
+    const state = cfStateStore.readCfState();
+    if (!state?.hostname) {
+      consoleLike.error("Missing hostname in Cloudflare state. Run setup first.");
+      return exit(1);
+    }
+    const targetPort = state?.localPort || port;
+    const localUrlArg = getCloudflareArg("--local-url");
+    const localPathArg = getCloudflareArg("--local-path");
+    let localPath = "/";
+    if (!localUrlArg && localPathArg) localPath = normalizePath(localPathArg);
+    const localUrl = localUrlArg || `http://127.0.0.1:${targetPort}${localPath}`;
+    let remotePath = localPath;
+    if (localUrlArg) {
+      try {
+        remotePath = new URL(localUrlArg).pathname || "/";
+      } catch {
+        remotePath = "/";
+      }
+    }
+    const remoteUrl = `https://${state.hostname}${remotePath}`;
+
+    function report(label, ok, detail) {
+      const status = ok ? "OK" : "FAIL";
+      consoleLike.log(`${label}: ${status}${detail ? ` (${detail})` : ""}`);
+    }
+
+    httpLike
+      .get(localUrl, { timeout: 3000 }, (res) => {
+        res.resume();
+        res.on("end", () => {
+          const ok = res.statusCode >= 200 && res.statusCode < 300;
+          const detail = `HTTP ${res.statusCode}: ${localUrl}`;
+          report("Local", ok, detail);
+          httpsLike
+            .get(remoteUrl, { timeout: 5000 }, (res2) => {
+              res2.resume();
+              const ok2 = res2.statusCode >= 200 && res2.statusCode < 300;
+              const isRedirect = res2.statusCode === 302;
+              if (ok2) {
+                report("Cloudflare", true, `HTTP ${res2.statusCode}`);
+              } else if (isRedirect) {
+                report("Cloudflare", true, "Access redirect (HTTP 302)");
+              } else {
+                report("Cloudflare", false, `HTTP ${res2.statusCode}`);
+              }
+              if (!ok2 && !isRedirect) {
+                if (res2.statusCode === 401 || res2.statusCode === 403) {
+                  consoleLike.log("Hint: Access policy may be blocking this request.");
+                }
+                if (res2.statusCode === 404) {
+                  consoleLike.log("Hint: Hostname or route may not match the tunnel.");
+                }
+              }
+              exit(ok && (ok2 || isRedirect) ? 0 : 1);
+            })
+            .on("timeout", () => {
+              report("Cloudflare", false, "timeout");
+              exit(1);
+            })
+            .on("error", () => {
+              report("Cloudflare", false, "connection failed");
+              exit(1);
+            });
+        });
+      })
+      .on("timeout", () => {
+        report("Local", false, `timeout: ${localUrl}`);
+        exit(1);
+      })
+      .on("error", () => {
+        report("Local", false, `connection failed: ${localUrl}`);
+        exit(1);
+      });
+    return undefined;
+  }
+
+  function cloudflareClean() {
+    try {
+      cfStateStore.clean();
+    } catch {
+      consoleLike.error("Failed to clean Cloudflare state.");
+      exit(1);
+      return;
+    }
+    consoleLike.log("Cloudflare state cleaned.");
+    exit(0);
+  }
+
+  function cloudflareToken(action, tokenValue) {
+    if (action === "set") {
+      if (!tokenValue) {
+        consoleLike.error("Missing token. Use: cloudflare token set --token <TOKEN>");
+        exit(1);
+        return;
+      }
+      cfStateStore.setToken(tokenValue);
+      if (cfStateStore.patchCfState) {
+        cfStateStore.patchCfState({
+          tokenFile: cfTokenFile,
+          tokenSetAt: new Date().toISOString(),
+        });
+      }
+      consoleLike.log(`Cloudflare token stored in ${cfTokenFile}.`);
+      exit(0);
+      return;
+    }
+    if (action === "clear") {
+      cfStateStore.clearToken();
+      if (cfStateStore.patchCfState) {
+        cfStateStore.patchCfState({ tokenFile: null, token: null });
+      }
+      consoleLike.log("Cloudflare token cleared.");
+      exit(0);
+      return;
+    }
+    if (action === "get") {
+      const state = cfStateStore.readCfState ? cfStateStore.readCfState() : null;
+      if (state?.tokenFile && fsLike.existsSync(state.tokenFile)) {
+        consoleLike.log("Cloudflare token is set.");
+        exit(0);
+        return;
+      }
+      consoleLike.log("Cloudflare token is not set.");
+      exit(1);
+      return;
+    }
+    consoleLike.error("Usage: cloudflare token <set|get|clear> [--token <TOKEN>]");
+    exit(1);
+  }
+
+  return {
+    cloudflareStart,
+    cloudflareStop,
+    cloudflareStatus,
+    cloudflareCheck,
+    cloudflareDiagnose,
+    cloudflareClean,
+    cloudflareToken,
+  };
+}
+
+module.exports = {
+  createCloudflareService,
+};