copilot-proxy-web 1.0.0

package/lib/terminal-buffer.js

@@ -0,0 +1,302 @@
+class TerminalBuffer {
+  constructor(cols = 80, rows = 24) {
+    this.cols = cols;
+    this.rows = rows;
+    this.scrollback = [];
+    this.buffer = this._makeBuffer(rows, cols);
+    this.cursorRow = 0;
+    this.cursorCol = 0;
+    this.dirtyRows = new Set();
+    this.state = "text";
+    this.csi = "";
+    this.osc = "";
+    this.oscEsc = false;
+  }
+
+  _makeBuffer(rows, cols) {
+    const buf = [];
+    for (let r = 0; r < rows; r += 1) {
+      const line = new Array(cols);
+      line.fill(" ");
+      buf.push(line);
+    }
+    return buf;
+  }
+
+  _blankLine() {
+    const line = new Array(this.cols);
+    line.fill(" ");
+    return line;
+  }
+
+  _rtrim(str) {
+    return str.replace(/\s+$/, "");
+  }
+
+  resize(cols, rows) {
+    const nextCols = Math.max(1, cols || this.cols);
+    const nextRows = Math.max(1, rows || this.rows);
+    if (nextCols !== this.cols) {
+      for (const line of this.buffer) {
+        if (line.length < nextCols) {
+          line.push(...new Array(nextCols - line.length).fill(" "));
+        } else if (line.length > nextCols) {
+          line.length = nextCols;
+        }
+      }
+      this.cols = nextCols;
+      if (this.cursorCol >= this.cols) this.cursorCol = this.cols - 1;
+    }
+    if (nextRows !== this.rows) {
+      if (nextRows < this.rows) {
+        const drop = this.rows - nextRows;
+        for (let i = 0; i < drop; i += 1) {
+          this.scrollback.push(this._rtrim(this.buffer[i].join("")));
+        }
+        this.buffer = this.buffer.slice(drop);
+        this.cursorRow = Math.max(0, this.cursorRow - drop);
+      } else {
+        for (let i = 0; i < nextRows - this.rows; i += 1) {
+          this.buffer.push(this._blankLine());
+        }
+      }
+      this.rows = nextRows;
+      if (this.cursorRow >= this.rows) this.cursorRow = this.rows - 1;
+    }
+    for (let r = 0; r < this.rows; r += 1) {
+      this.dirtyRows.add(r);
+    }
+  }
+
+  _scrollUp(lines = 1) {
+    for (let i = 0; i < lines; i += 1) {
+      const removed = this.buffer.shift();
+      if (removed) this.scrollback.push(this._rtrim(removed.join("")));
+      this.buffer.push(this._blankLine());
+    }
+    for (let r = 0; r < this.rows; r += 1) {
+      this.dirtyRows.add(r);
+    }
+  }
+
+  _newline() {
+    this.cursorRow += 1;
+    if (this.cursorRow >= this.rows) {
+      this._scrollUp(1);
+      this.cursorRow = this.rows - 1;
+    }
+  }
+
+  _putChar(ch) {
+    if (this.cursorCol >= this.cols) {
+      this._newline();
+      this.cursorCol = 0;
+    }
+    this.buffer[this.cursorRow][this.cursorCol] = ch;
+    this.dirtyRows.add(this.cursorRow);
+    this.cursorCol += 1;
+    if (this.cursorCol > this.cols) {
+      this.cursorCol = this.cols;
+    }
+  }
+
+  _eraseInLine(mode = 0) {
+    const line = this.buffer[this.cursorRow];
+    if (!line) return;
+    if (mode === 2) {
+      line.fill(" ");
+      this.dirtyRows.add(this.cursorRow);
+      return;
+    }
+    if (mode === 1) {
+      for (let i = 0; i <= this.cursorCol; i += 1) line[i] = " ";
+      this.dirtyRows.add(this.cursorRow);
+      return;
+    }
+    for (let i = this.cursorCol; i < this.cols; i += 1) line[i] = " ";
+    this.dirtyRows.add(this.cursorRow);
+  }
+
+  _eraseInDisplay(mode = 0) {
+    if (mode === 2) {
+      for (let r = 0; r < this.rows; r += 1) {
+        this.buffer[r].fill(" ");
+        this.dirtyRows.add(r);
+      }
+      return;
+    }
+    if (mode === 1) {
+      for (let r = 0; r < this.cursorRow; r += 1) {
+        this.buffer[r].fill(" ");
+        this.dirtyRows.add(r);
+      }
+      this._eraseInLine(1);
+      return;
+    }
+    this._eraseInLine(0);
+    for (let r = this.cursorRow + 1; r < this.rows; r += 1) {
+      this.buffer[r].fill(" ");
+      this.dirtyRows.add(r);
+    }
+  }
+
+  _handleCsi(sequence) {
+    const code = sequence.slice(-1);
+    const params = sequence.slice(0, -1).replace(/^\?/, "");
+    const parts = params.length ? params.split(";") : [];
+    const nums = parts.map((p) => (p === "" ? NaN : Number(p)));
+    const n1 = Number.isFinite(nums[0]) ? nums[0] : 1;
+    const n2 = Number.isFinite(nums[1]) ? nums[1] : 1;
+    switch (code) {
+      case "A":
+        this.cursorRow = Math.max(0, this.cursorRow - n1);
+        break;
+      case "B":
+        this.cursorRow = Math.min(this.rows - 1, this.cursorRow + n1);
+        break;
+      case "C":
+        this.cursorCol = Math.min(this.cols - 1, this.cursorCol + n1);
+        break;
+      case "D":
+        this.cursorCol = Math.max(0, this.cursorCol - n1);
+        break;
+      case "G":
+        this.cursorCol = Math.min(this.cols - 1, Math.max(0, n1 - 1));
+        break;
+      case "H":
+      case "f":
+        this.cursorRow = Math.min(this.rows - 1, Math.max(0, n1 - 1));
+        this.cursorCol = Math.min(this.cols - 1, Math.max(0, n2 - 1));
+        break;
+      case "J":
+        this._eraseInDisplay(Number.isFinite(nums[0]) ? nums[0] : 0);
+        break;
+      case "K":
+        this._eraseInLine(Number.isFinite(nums[0]) ? nums[0] : 0);
+        break;
+      case "m":
+      default:
+        break;
+    }
+  }
+
+  write(data = "") {
+    for (const ch of String(data)) {
+      if (this.state === "text") {
+        if (ch === "\u001b") {
+          this.state = "escape";
+          continue;
+        }
+        if (ch === "\r") {
+          this.cursorCol = 0;
+          continue;
+        }
+        if (ch === "\n") {
+          this._newline();
+          continue;
+        }
+        if (ch === "\b") {
+          this.cursorCol = Math.max(0, this.cursorCol - 1);
+          continue;
+        }
+        if (ch === "\t") {
+          const nextTab = Math.floor(this.cursorCol / 8 + 1) * 8;
+          this.cursorCol = Math.min(this.cols - 1, nextTab);
+          continue;
+        }
+        if (ch < " ") {
+          continue;
+        }
+        this._putChar(ch);
+        continue;
+      }
+
+      if (this.state === "escape") {
+        if (ch === "[") {
+          this.state = "csi";
+          this.csi = "";
+          continue;
+        }
+        if (ch === "]") {
+          this.state = "osc";
+          this.osc = "";
+          this.oscEsc = false;
+          continue;
+        }
+        if (ch === "E") {
+          this.cursorCol = 0;
+          this._newline();
+        } else if (ch === "D") {
+          this._newline();
+        } else if (ch === "M") {
+          this.cursorRow = Math.max(0, this.cursorRow - 1);
+        }
+        this.state = "text";
+        continue;
+      }
+
+      if (this.state === "csi") {
+        this.csi += ch;
+        if (/[A-Za-z~]$/.test(ch)) {
+          this._handleCsi(this.csi);
+          this.csi = "";
+          this.state = "text";
+        }
+        continue;
+      }
+
+      if (this.state === "osc") {
+        if (this.oscEsc) {
+          if (ch === "\\") {
+            this.state = "text";
+            this.oscEsc = false;
+            continue;
+          }
+          this.oscEsc = false;
+        }
+        if (ch === "\u0007") {
+          this.state = "text";
+          continue;
+        }
+        if (ch === "\u001b") {
+          this.oscEsc = true;
+          continue;
+        }
+        this.osc += ch;
+      }
+    }
+  }
+
+  getLines({ includeScrollback = true } = {}) {
+    const lines = [];
+    if (includeScrollback && this.scrollback.length) {
+      lines.push(...this.scrollback);
+    }
+    for (const row of this.buffer) {
+      lines.push(this._rtrim(row.join("")));
+    }
+    return lines;
+  }
+
+  getRow(row) {
+    const line = this.buffer[row];
+    if (!line) return "";
+    return this._rtrim(line.join(""));
+  }
+
+  consumeDirtyLines() {
+    if (!this.dirtyRows.size) return [];
+    const rows = Array.from(this.dirtyRows).sort((a, b) => a - b);
+    this.dirtyRows.clear();
+    const out = [];
+    for (const r of rows) {
+      const line = this.buffer[r];
+      if (line) out.push({ row: r, text: this._rtrim(line.join("")) });
+    }
+    return out;
+  }
+}
+
+module.exports = {
+  TerminalBuffer,
+};

package/lib/ws.js

@@ -0,0 +1,256 @@
+const WebSocket = require("ws");
+const { normalizeText } = require("./pty");
+const {
+  recordFailure,
+  clearFailures,
+  isBlocked,
+} = require("./auth-rate-limit");
+
+function parseSessionId(request) {
+  const url = request.url || "";
+  const idx = url.indexOf("?");
+  if (idx === -1) return null;
+  const params = new URLSearchParams(url.slice(idx + 1));
+  return params.get("sessionId");
+}
+
+function decodeAuthProtocol(protocol) {
+  if (!protocol || !protocol.startsWith("auth.")) return null;
+  const enc = protocol.slice("auth.".length);
+  try {
+    return Buffer.from(enc, "base64url").toString("utf8");
+  } catch {
+    return null;
+  }
+}
+
+function extractProtocols(header) {
+  if (!header) return [];
+  return header
+    .split(",")
+    .map((p) => p.trim())
+    .filter(Boolean);
+}
+
+function firstForwardedIp(value) {
+  if (typeof value !== "string" || value.length === 0) return "";
+  const first = value.split(",")[0].trim();
+  return first || "";
+}
+
+function getClientIp(request, useXForwardedFor = false) {
+  if (useXForwardedFor) {
+    const forwarded = firstForwardedIp(request.headers?.["x-forwarded-for"]);
+    if (forwarded) return forwarded;
+  }
+  return request.socket?.remoteAddress || "";
+}
+
+function attachWsServer({
+  server,
+  sessionManager,
+  debugWs,
+  debugStream,
+  authToken,
+  useXForwardedFor = false,
+  accessLog,
+  accessLogMode = "auth",
+}) {
+  function shouldLogWs(event) {
+    if (accessLogMode === "off") return false;
+    if (accessLogMode === "all") return true;
+    if (event.type === "ws_upgrade") {
+      return event.status === "blocked" || event.status === "rejected";
+    }
+    return false;
+  }
+
+  function writeWsAccess(event) {
+    if (!accessLog) return;
+    if (!shouldLogWs(event)) return;
+    accessLog(event);
+  }
+
+  const wss = new WebSocket.Server({
+    noServer: true,
+    handleProtocols: authToken
+      ? (protocols) => {
+          for (const protocol of protocols) {
+            const token = decodeAuthProtocol(protocol);
+            if (token && token === authToken) return protocol;
+          }
+          return false;
+        }
+      : undefined,
+  });
+
+  server.on("upgrade", (request, socket, head) => {
+    if (request.url && request.url.startsWith("/ws")) {
+      const ip = getClientIp(request, useXForwardedFor);
+      if (authToken) {
+        if (isBlocked(ip)) {
+          writeWsAccess({
+            type: "ws_upgrade",
+            ip,
+            path: request.url,
+            status: "blocked",
+            auth: "blocked",
+          });
+          socket.destroy();
+          return;
+        }
+        const offered = extractProtocols(request.headers["sec-websocket-protocol"]);
+        const ok = offered.some((p) => decodeAuthProtocol(p) === authToken);
+        if (!ok) {
+          recordFailure(ip);
+          writeWsAccess({
+            type: "ws_upgrade",
+            ip,
+            path: request.url,
+            status: "rejected",
+            auth: "failed",
+          });
+          socket.destroy();
+          return;
+        }
+        clearFailures(ip);
+      }
+      writeWsAccess({
+        type: "ws_upgrade",
+        ip,
+        path: request.url,
+        status: "accepted",
+        auth: authToken ? "ok" : "disabled",
+      });
+      wss.handleUpgrade(request, socket, head, (ws) => {
+        wss.emit("connection", ws, request);
+      });
+    } else {
+      socket.destroy();
+    }
+  });
+
+  wss.on("connection", (ws, request) => {
+    const ip = getClientIp(request, useXForwardedFor);
+    const sessionId = parseSessionId(request);
+    const session =
+      (sessionId && sessionManager.getSession(sessionId)) ||
+      sessionManager.getDefaultSession();
+    if (!session || !session.term) {
+      writeWsAccess({
+        type: "ws_connection",
+        ip,
+        path: request.url || "/ws",
+        status: "closed",
+        reason: "session_not_found",
+      });
+      ws.close();
+      return;
+    }
+    const { clients, history } = session;
+    clients.add(ws);
+    writeWsAccess({
+      type: "ws_connection",
+      ip,
+      path: request.url || "/ws",
+      status: "open",
+      sessionId: session.id,
+    });
+    if (history.length > 0) {
+      ws.send(history.join(""));
+    }
+    ws.on("message", (message, isBinary) => {
+      if (!session.term) return;
+      if (isBinary) {
+        const buf = Buffer.from(message);
+        const type = buf[0];
+        const payload = buf.subarray(1);
+        const data = payload.toString();
+        if (type === 1) {
+          if (debugWs) {
+            debugStream.write(
+              `[WS] keys(bin) ${data.length} chars hex=${payload.toString("hex")}\n`
+            );
+          }
+          if (session.writeInput) session.writeInput(data);
+          else session.term.write(data);
+          return;
+        }
+        if (type === 2) {
+          if (!data.trim()) return;
+          const normalized = normalizeText(data).replace(/\n/g, "\r") + "\r";
+          if (debugWs) {
+            debugStream.write(
+              `[WS] text(bin) ${data.length} chars hex=${payload.toString("hex")}\n`
+            );
+          }
+          if (session.writeInput) session.writeInput(normalized);
+          else session.term.write(normalized);
+          return;
+        }
+      }
+
+      const raw = message.toString();
+      let handled = false;
+      try {
+        const payload = JSON.parse(raw);
+        if (payload && payload.type === "resize") {
+          const cols = Number(payload.cols);
+          const rows = Number(payload.rows);
+          if (Number.isFinite(cols) && Number.isFinite(rows)) {
+          session.term.resize(cols, rows);
+          if (session.screen) session.screen.resize(cols, rows);
+        }
+        handled = true;
+      }
+      if (payload && payload.type === "keys" && typeof payload.data === "string") {
+        if (debugWs) {
+          debugStream.write(`[WS] keys ${payload.data.length} chars\n`);
+        }
+          if (session.writeInput) session.writeInput(payload.data);
+          else session.term.write(payload.data);
+          handled = true;
+        }
+      if (payload && payload.type === "text" && typeof payload.data === "string") {
+        const text = payload.data;
+        if (!text.trim()) return;
+        const normalized = normalizeText(text).replace(/\n/g, "\r") + "\r";
+        if (debugWs) {
+          debugStream.write(`[WS] text ${text.length} chars\n`);
+        }
+        if (session.writeInput) session.writeInput(normalized);
+        else session.term.write(normalized);
+        handled = true;
+      }
+      } catch {
+        // fall back to plain text
+      }
+      if (!handled) {
+        const text = raw;
+        if (!text.trim()) return;
+        const normalized = normalizeText(text).replace(/\n/g, "\r") + "\r";
+        if (debugWs) {
+          debugStream.write(`[WS] plain ${text.length} chars\n`);
+        }
+        if (session.writeInput) session.writeInput(normalized);
+        else session.term.write(normalized);
+      }
+    });
+    ws.on("close", () => {
+      clients.delete(ws);
+      writeWsAccess({
+        type: "ws_connection",
+        ip,
+        path: request.url || "/ws",
+        status: "close",
+        sessionId: session.id,
+      });
+    });
+  });
+
+  return wss;
+}
+
+module.exports = {
+  attachWsServer,
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "copilot-proxy-web",
+  "version": "1.0.0",
+  "description": "Proxy GitHub Copilot CLI through a PTY with a Web UI, WebSocket streaming, and an HTTP API.",
+  "main": "copilot-proxy.js",
+  "bin": {
+    "copilot-proxy-web": "bin/run-web.js"
+  },
+  "scripts": {
+    "copilot-proxy-web": "node bin/run-web.js",
+    "clean:appledouble": "find . -name '._*' -type f -not -path './.git/*' -delete",
+    "test": "node --test test/*.test.js",
+    "test:ui": "npm run clean:appledouble && playwright test",
+    "ws": "node bin/wss-client.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "public/",
+    "copilot-proxy.js",
+    "README.md",
+    "README.arch.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "copilot",
+    "proxy",
+    "pty",
+    "websocket",
+    "cli",
+    "web"
+  ],
+  "author": "changyy",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "express": "^5.2.1",
+    "https-proxy-agent": "^7.0.6",
+    "node-pty": "^1.1.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.50.0"
+  }
+}