@hemacharanpyla/infinitycli 1.0.0

package/bin/infinity.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import "../chat.js";

package/chat.js

@@ -0,0 +1,509 @@
+#!/usr/bin/env node
+
+import { stdin, stdout, exit } from "process";
+import readline from "readline";
+import os from "os";
+
+// ─── ANSI ──────────────────────────────────────────────────
+const R = "\x1b[0m", B = "\x1b[1m", D = "\x1b[2m";
+const O = "\x1b[38;5;208m", BO = "\x1b[1;38;5;208m";
+const P = "\x1b[35m", BP = "\x1b[1;35m";
+const C = "\x1b[36m", BC = "\x1b[1;36m";
+const G = "\x1b[32m", Y = "\x1b[33m";
+const R2 = "\x1b[31m", GR = "\x1b[90m";
+const CL = "\x1b[0K";
+const CURSOR_HIDE = "\x1b[?25l", CURSOR_SHOW = "\x1b[?25h";
+
+// ─── Config ────────────────────────────────────────────────
+const API = process.env.API_BASE || "http://localhost:3000";
+const MODEL = process.env.MODEL || "GPT-4o";
+const USER = os.userInfo().username;
+
+// ─── Terminal dimensions ──────────────────────────────────
+const H = Math.max(24, stdout.rows || 24);
+const W = Math.min(Math.max(60, (stdout.columns || 80) - 4), 120);
+const CONTENT_H = H - 8; // rows available for content
+
+// ─── Layout rows (0-indexed) ──────────────────────────────
+const R_TOP = 0;
+const R_TITLE = 1;
+const R_SEP1 = 2;
+const R_CONTENT_START = 3;
+const R_SEP2 = H - 5;
+const R_BLANK = H - 4;
+const R_PROMPT = H - 3;
+const R_SHORTCUTS = H - 2;
+const R_BOTTOM = H - 1;
+
+// ─── State ─────────────────────────────────────────────────
+const state = {
+  messages: [],
+  input: "",
+  history: [],
+  histIdx: -1,
+  status: "initializing",
+  loading: false,
+  connected: false,
+  sessionId: null,
+  spinnerIdx: 0,
+  spinnerTimer: null,
+  view: "dashboard", // "dashboard" | "chat"
+  showHelp: false,
+};
+
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+function time() {
+  return new Date().toLocaleTimeString("en-US", { hour12: false });
+}
+
+function fmtDur(ms) {
+  return ms < 1000 ? `${ms}ms` : `${(ms / 1000).toFixed(1)}s`;
+}
+
+// ─── HTTP ──────────────────────────────────────────────────
+async function api(method, path, body) {
+  const opts = {
+    method,
+    headers: { "Content-Type": "application/json" },
+  };
+  if (body) opts.body = JSON.stringify(body);
+  const res = await fetch(`${API}${path}`, opts);
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error || `HTTP ${res.status}`);
+  }
+  return res.status === 204 ? null : res.json();
+}
+
+// ─── ANSI-aware length ────────────────────────────────────
+const reAnsi = /\x1b\[\d*(;\d*)*m/g;
+function vis(s) { return s.replace(reAnsi, ""); }
+
+// ─── Box helpers ───────────────────────────────────────────
+const BOX = {
+  top:    `${O}╭${R}${O}${"─".repeat(W + 2)}${R}${O}╮${R}`,
+  sep:    `${O}├${R}${O}${"─".repeat(W + 2)}${R}${O}┤${R}`,
+  bot:    `${O}╰${R}${O}${"─".repeat(W + 2)}${R}${O}╯${R}`,
+  empty:  `${O}│${R}${" ".repeat(W + 2)}${O}│${R}`,
+  line:   (t) => `${O}│${R} ${vis(t).padEnd(W)} ${O}│${R}`,
+  lineR:  (l, r) => {
+    const pad = Math.max(0, W - vis(l).length - vis(r).length);
+    return `${O}│${R} ${l}${" ".repeat(pad)}${r} ${O}│${R}`;
+  },
+};
+
+function center(text, total) {
+  const pad = Math.floor((total - text.length) / 2);
+  return " ".repeat(Math.max(0, pad)) + text + " ".repeat(Math.max(0, total - text.length - pad));
+}
+
+// ─── Screen builder ───────────────────────────────────────
+function pos(row, col = 0) {
+  return `\x1b[${row + 1};${col + 1}H`;
+}
+
+function clearScreen() {
+  stdout.write(`\x1b[${H}S\x1b[2J\x1b[3J\x1b[H`); // scroll H lines, clear
+}
+
+const SEP = `${GR}${"─".repeat(W)}${R}`;
+
+// ─── Dashboard content ────────────────────────────────────
+function buildDashboard() {
+  const lines = [];
+  lines.push("");
+  lines.push(`  ${BO}Welcome back ${G}${USER}${R}${BO}${R}`);
+  lines.push("");
+  lines.push(`  ${D}∞${R} ${BP}Infinity CLI${R}`);
+  lines.push(`  ${GR}Model:${R}  ${BO}${MODEL}${R}`);
+  lines.push(`  ${GR}Plan:${R}   ${P}Pro${R}`);
+  lines.push(`  ${GR}Path:${R}   ${C}${process.cwd()}${R}`);
+  lines.push("");
+  lines.push(`  ${GR}${SEP}${R}`);
+  lines.push("");
+  lines.push(`  ${B}Tips for getting started${R}`);
+  lines.push(`  ${O}•${R}  ${G}/help${R}      Show available commands`);
+  lines.push(`  ${O}•${R}  ${G}/clear${R}     Clear conversation`);
+  lines.push(`  ${O}•${R}  ${G}/exit${R}      Exit the session`);
+  lines.push(`  ${O}•${R}  ${G}/status${R}    Show session info`);
+  lines.push("");
+  lines.push(`  ${B}Recent activity${R}`);
+  lines.push(`  ${GR}  No recent activity${R}`);
+  lines.push("");
+
+  while (lines.length < CONTENT_H) lines.push("");
+  if (lines.length > CONTENT_H) lines.length = CONTENT_H;
+  return lines;
+}
+
+// ─── Help panel ───────────────────────────────────────────
+function buildHelpPanel() {
+  const cmds = [
+    ["/help",      "Show available commands"],
+    ["/clear",     "Clear conversation"],
+    ["/exit",      "Exit the chat session"],
+    ["/status",    "Show session & connection info"],
+  ];
+  const sc = [
+    ["Enter",        "Send message"],
+    ["Shift+Enter",  "Newline in input"],
+    ["↑/↓",          "History navigation"],
+    ["Ctrl+L",       "Clear chat"],
+    ["Ctrl+U",       "Clear current input"],
+    ["Ctrl+C",       "Exit application"],
+  ];
+
+  const lines = [];
+  lines.push("");
+  lines.push(`  ${BO}${"─".repeat(28)}${R}`);
+  lines.push(`  ${B}Commands${R}`);
+  for (const [k, v] of cmds) {
+    lines.push(`  ${O}●${R}  ${G}${k}${R}  ${GR}${v}${R}`);
+  }
+  lines.push("");
+  lines.push(`  ${B}Shortcuts${R}`);
+  for (const [k, v] of sc) {
+    lines.push(`  ${O}●${R}  ${BC}${k}${R}  ${GR}${v}${R}`);
+  }
+  lines.push("");
+  lines.push(`  ${GR}Press ${O}?${R}${GR} again or type a command to close${R}`);
+  lines.push("");
+
+  while (lines.length < CONTENT_H) lines.push("");
+  if (lines.length > CONTENT_H) lines.length = CONTENT_H;
+  return lines;
+}
+
+// ─── Chat content ─────────────────────────────────────────
+function buildChat() {
+  const entries = [];
+
+  for (const msg of state.messages) {
+    const role = msg.role === "user" ? `${BC}You${R}` : `${BP}Infinity${R}`;
+    entries.push(`  ${role} (${GR}${msg.ts}${R})`);
+    for (const line of msg.content.split("\n")) {
+      entries.push(`  ${line}`);
+    }
+    if (msg.meta) {
+      entries.push(`  ${GR}╰ ${msg.meta}${R}`);
+    }
+    entries.push("");
+  }
+
+  // Trim from front if too many lines
+  while (entries.length > CONTENT_H) {
+    const cut = entries.indexOf("") + 1;
+    if (cut > 0 && cut < entries.length) {
+      entries.splice(0, cut);
+    } else {
+      entries.splice(0, 2);
+    }
+  }
+
+  while (entries.length < CONTENT_H) entries.push("");
+  if (entries.length > CONTENT_H) entries.length = CONTENT_H;
+  return entries;
+}
+
+// ─── Full render ──────────────────────────────────────────
+function render(focusInput = true) {
+  const content = state.showHelp ? buildHelpPanel() : (state.view === "dashboard" ? buildDashboard() : buildChat());
+  const title = `${BO}Infinity CLI${R}  ${GR}v1.0${R}`;
+
+  const statusIcon = state.loading ? `${Y}●${R}` : state.connected ? `${G}●${R}` : `${R2}○${R}`;
+  const statusRight = `${GR}${MODEL}${R}  ${statusIcon} ${GR}${state.status}${R}`;
+  const titleLine = `${" ".repeat(1)}${title}${" ".repeat(Math.max(0, W - vis(title).length - vis(statusRight).length))}${statusRight}`;
+
+  let out = "";
+  out += pos(R_TOP) + BOX.top;
+  out += pos(R_TITLE) + BOX.line(titleLine);
+  out += pos(R_SEP1) + BOX.sep;
+
+  for (let i = 0; i < CONTENT_H; i++) {
+    const text = content[i] || "";
+    out += pos(R_CONTENT_START + i) + BOX.line(text);
+  }
+
+  out += pos(R_SEP2) + BOX.sep;
+  out += pos(R_BLANK) + BOX.empty;
+
+  const promptText = `${P}>${R} ${state.input}`;
+  out += pos(R_PROMPT) + BOX.line(promptText);
+
+  const shortcuts = `${GR}?${R} ${GR}for help${R}  ${GR}│${R}  ${GR}↑↓${R} ${GR}history${R}  ${GR}│${R}  ${GR}Ctrl+C${R} ${GR}exit${R}`;
+  out += pos(R_SHORTCUTS) + BOX.lineR(shortcuts, state.loading ? `${Y}● ${state.status}${R}` : `${GR}${state.messages.length} msgs${R}`);
+
+  out += pos(R_BOTTOM) + BOX.bot;
+
+  if (focusInput) {
+    const cursorCol = 3 + 2 + state.input.length; // │ > text → cursor after text
+    out += pos(R_PROMPT, cursorCol);
+  }
+
+  stdout.write(out);
+}
+
+// ─── Prompt-only update (while typing) ────────────────────
+function renderPrompt() {
+  const promptText = `${P}>${R} ${state.input}`;
+  stdout.write(`${pos(R_PROMPT)}${CL}${BOX.line(promptText)}`);
+  const cursorCol = 3 + 2 + state.input.length;
+  stdout.write(pos(R_PROMPT, cursorCol));
+}
+
+// ─── Status-only update ───────────────────────────────────
+function updateStatus() {
+  const statusIcon = state.loading ? `${Y}●${R}` : state.connected ? `${G}●${R}` : `${R2}○${R}`;
+  const statusRight = `${GR}${MODEL}${R}  ${statusIcon} ${GR}${state.status}${R}`;
+  const title = `${BO}Infinity CLI${R}  ${GR}v1.0${R}`;
+  const titleLine = `${" ".repeat(1)}${title}${" ".repeat(Math.max(0, W - vis(title).length - vis(statusRight).length))}${statusRight}`;
+  stdout.write(`${pos(R_TITLE)}${CL}${BOX.line(titleLine)}`);
+}
+
+// ─── Spinner ───────────────────────────────────────────────
+function startSpinner() {
+  state.spinnerIdx = 0;
+  const tick = () => {
+    if (!state.loading) return;
+    state.spinnerIdx = (state.spinnerIdx + 1) % SPINNER.length;
+    updateStatus();
+    state.spinnerTimer = setTimeout(tick, 100);
+  };
+  state.spinnerTimer = setTimeout(tick, 100);
+}
+
+function stopSpinner() {
+  if (state.spinnerTimer) {
+    clearTimeout(state.spinnerTimer);
+    state.spinnerTimer = null;
+  }
+}
+
+// ─── Add message & re-render ──────────────────────────────
+function addMessage(role, content, meta) {
+  state.messages.push({ role, content, meta, ts: time() });
+  if (state.view === "dashboard") state.view = "chat";
+  render();
+}
+
+// ─── Input handling ───────────────────────────────────────
+function handleKeypress(str, key) {
+  if (!key) return;
+
+  if (key.ctrl && key.name === "c") {
+    if (state.messages.length > 0) {
+      render();
+      stdout.write(`${pos(R_SHORTCUTS)}${CL}${BOX.lineR(`${Y}Press Ctrl+C again or type /exit to quit${R}`, "")}`);
+      stdout.write(pos(R_PROMPT, 4 + state.input.length));
+    } else {
+      shutdown();
+    }
+    return;
+  }
+
+  if (key.name === "return") {
+    if (state.loading) return;
+    if (key.shift) {
+      state.input += "\n";
+      renderPrompt();
+      return;
+    }
+    const line = state.input.trimEnd();
+    state.input = "";
+    if (line) {
+      renderPrompt();
+      processLine(line);
+    }
+    return;
+  }
+
+  if (key.name === "backspace" || key.name === "delete") {
+    if (state.input.length > 0) {
+      state.input = state.input.slice(0, -1);
+      renderPrompt();
+    }
+    return;
+  }
+
+  if (key.name === "up") {
+    if (state.history.length > 0 && state.histIdx < state.history.length - 1) {
+      state.histIdx++;
+      state.input = state.history[state.history.length - 1 - state.histIdx];
+      renderPrompt();
+    }
+    return;
+  }
+
+  if (key.name === "down") {
+    if (state.histIdx > 0) {
+      state.histIdx--;
+      state.input = state.history[state.history.length - 1 - state.histIdx];
+    } else {
+      state.histIdx = -1;
+      state.input = "";
+    }
+    renderPrompt();
+    return;
+  }
+
+  if (key.ctrl && key.name === "l") { cmdClear(); return; }
+  if (key.ctrl && key.name === "u") { state.input = ""; renderPrompt(); return; }
+
+  if (str && !key.ctrl && !key.meta) {
+    state.input += str;
+    renderPrompt();
+  }
+}
+
+// ─── Command processing ────────────────────────────────────
+async function processLine(line) {
+  state.history.push(line);
+  state.histIdx = -1;
+
+  if (line === "?") {
+    state.showHelp = !state.showHelp;
+    render();
+    return;
+  }
+
+  state.showHelp = false;
+
+  if (line.startsWith("/")) {
+    handleCommand(line);
+    return;
+  }
+
+  // Send message
+  addMessage("user", line);
+
+  state.loading = true;
+  state.status = "Thinking...";
+  updateStatus();
+  startSpinner();
+
+  const start = Date.now();
+
+  try {
+    if (!state.sessionId) {
+      state.status = "Connecting...";
+      updateStatus();
+      const sess = await api("POST", "/pages");
+      state.sessionId = sess.id;
+      state.connected = true;
+      state.status = "Thinking...";
+      updateStatus();
+    }
+
+    const result = await api("POST", `/pages/${state.sessionId}/messages`, { message: line });
+    const elapsed = Date.now() - start;
+    state.loading = false;
+    stopSpinner();
+    addMessage("infinity", result.response, `${fmtDur(elapsed)}`);
+    state.status = "Ready";
+    updateStatus();
+  } catch (err) {
+    const elapsed = Date.now() - start;
+    state.loading = false;
+    stopSpinner();
+    addMessage("infinity", `${R2}Error:${R} ${err.message}`, `failed after ${fmtDur(elapsed)}`);
+    state.status = `Error — ${err.message}`;
+    updateStatus();
+  }
+}
+
+function handleCommand(line) {
+  const cmd = line.split(/\s+/)[0].toLowerCase();
+  switch (cmd) {
+    case "/help": case "/h": case "/?":
+      cmdHelp(); break;
+    case "/clear": case "/cls":
+      cmdClear(); break;
+    case "/exit": case "/quit":
+      shutdown(); break;
+    case "/status":
+      cmdStatus(); break;
+    default:
+      render();
+      stdout.write(`${pos(R_CONTENT_START)}${CL}${BOX.line(`${R2}✕ unknown command:${R} ${line}`)}`);
+      stdout.write(`${pos(R_CONTENT_START + 1)}${CL}${BOX.line(`${GR}type ${B}/help${R}${GR} for available commands${R}`)}`);
+      stdout.write(pos(R_PROMPT, 4));
+  }
+}
+
+function cmdHelp() {
+  state.showHelp = !state.showHelp;
+  render();
+}
+
+function cmdClear() {
+  state.messages = [];
+  state.view = "dashboard";
+  render();
+}
+
+function cmdStatus() {
+  const lines = [
+    "",
+    `  ${BO}Session${R}`,
+    `  ${GR}ID:${R}        ${state.sessionId || `${R2}none${R}`}`,
+    `  ${GR}messages:${R}  ${state.messages.length}`,
+    `  ${GR}connected:${R} ${state.connected ? `${G}yes${R}` : `${R2}no${R}`}`,
+    `  ${GR}server:${R}    ${API}`,
+    `  ${GR}model:${R}     ${MODEL}`,
+    "",
+  ];
+  while (lines.length < CONTENT_H) lines.push("");
+  if (lines.length > CONTENT_H) lines.length = CONTENT_H;
+
+  for (let i = 0; i < CONTENT_H; i++) {
+    stdout.write(`${pos(R_CONTENT_START + i)}${CL}${BOX.line(lines[i])}`);
+  }
+  stdout.write(pos(R_PROMPT, 4));
+}
+
+// ─── Cleanup ───────────────────────────────────────────────
+async function shutdown() {
+  stopSpinner();
+  try {
+    if (state.sessionId) await api("DELETE", `/pages/${state.sessionId}`);
+  } catch {}
+  stdout.write(CURSOR_SHOW);
+  stdout.write(`\x1b[${H + 1};1H`);
+  stdout.write(`\n  ${GR}goodbye from${R} ${BO}Infinity CLI${R} ${GR}${"♥"}${R}\n`);
+  exit(0);
+}
+
+// ─── Init ──────────────────────────────────────────────────
+async function init() {
+  stdout.write(CURSOR_HIDE);
+  clearScreen();
+  stdout.write(`\x1b]0;Infinity CLI\x07`);
+
+  readline.emitKeypressEvents(stdin);
+  try { if (stdin.isTTY) stdin.setRawMode(true); } catch {}
+  stdin.on("keypress", handleKeypress);
+
+  state.view = "dashboard";
+  state.status = "Connecting...";
+  render();
+
+  try {
+    const health = await api("GET", "/health");
+    state.connected = health.ok;
+    state.status = state.connected
+      ? `Ready  —  ${health.sessions} session${health.sessions !== 1 ? "s" : ""} active`
+      : "Server online, no browser yet";
+    updateStatus();
+  } catch {
+    state.connected = false;
+    state.status = "start the server: node server.js";
+    updateStatus();
+  }
+}
+
+init().catch((err) => {
+  stdout.write(CURSOR_SHOW);
+  console.error("Fatal:", err);
+  exit(1);
+});

package/cookies/chatgpt.json

@@ -0,0 +1,11 @@
+[
+  {
+    "name": "__Secure-next-auth.session-token",
+    "value": "your-session-token-here",
+    "domain": ".chatgpt.com",
+    "path": "/",
+    "httpOnly": true,
+    "secure": true,
+    "sameSite": "Lax"
+  }
+]

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@hemacharanpyla/infinitycli",
+  "version": "1.0.0",
+  "description": "∞ Infinity CLI — terminal AI chat with real-time response timing",
+  "type": "module",
+  "bin": {
+    "infinity": "bin/infinity.js"
+  },
+  "scripts": {
+    "server": "node server.js",
+    "chat": "node chat.js",
+    "start": "node server.js",
+    "infinity": "node bin/infinity.js",
+    "prepublishOnly": "node --check bin/infinity.js && node --check chat.js"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "chat",
+    "terminal",
+    "assistant",
+    "chatgpt",
+    "puppeteer"
+  ],
+  "author": "Charan <hemacharanpyla@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hemacharanpyla/infinity-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hemacharanpyla/infinity-cli/issues"
+  },
+  "homepage": "https://github.com/hemacharanpyla/infinity-cli#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "chat.js",
+    "server.js",
+    "cookies/",
+    "README.md"
+  ],
+  "dependencies": {
+    "express": "^4.22.2",
+    "puppeteer": "^23.11.1"
+  }
+}

package/server.js

@@ -0,0 +1,424 @@
+import express from "express";
+import puppeteer from "puppeteer";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+
+const app = express();
+const publicPath = path.resolve("public");
+
+app.use(express.static(publicPath));
+
+const PORT = process.env.PORT || 3000;
+const CHATGPT_URL = "https://chatgpt.com/";
+
+const CHROME_PATH =
+  process.env.CHROME_PATH ||
+  "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe";
+
+const CHROME_DEBUG_PORT = process.env.CHROME_DEBUG_PORT || "9222";
+const CHROME_USER_DATA_DIR =
+  process.env.CHROME_USER_DATA_DIR || "C:\\chrome-debug";
+const COOKIES_PATH = process.env.COOKIES_PATH || "./cookies/chatgpt.json";
+
+function positiveInt(value, fallback) {
+  const number = Number.parseInt(value, 10);
+  return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+
+const MAX_SESSIONS = positiveInt(process.env.MAX_SESSIONS, 20);
+const MAX_CONCURRENT_PAGE_CREATES = positiveInt(
+  process.env.MAX_CONCURRENT_PAGE_CREATES,
+  3
+);
+const MAX_CONCURRENT_MESSAGES = positiveInt(
+  process.env.MAX_CONCURRENT_MESSAGES,
+  5
+);
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const sessions = new Map();
+let chromeProcess = null;
+let browser = null;
+let initializing = null;
+
+app.use(express.json({ limit: "1mb" }));
+
+class Semaphore {
+  constructor(max) {
+    this.max = max;
+    this.active = 0;
+    this.queue = [];
+  }
+
+  get queued() {
+    return this.queue.length;
+  }
+
+  async run(task) {
+    await this.acquire();
+    try {
+      return await task();
+    } finally {
+      this.release();
+    }
+  }
+
+  acquire() {
+    if (this.active < this.max) {
+      this.active += 1;
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+      return;
+    }
+    this.active -= 1;
+  }
+}
+
+const pageCreateLimiter = new Semaphore(MAX_CONCURRENT_PAGE_CREATES);
+const messageLimiter = new Semaphore(MAX_CONCURRENT_MESSAGES);
+
+function loadCookies() {
+  if (!existsSync(COOKIES_PATH)) {
+    throw new Error(`Cookies file not found at ${COOKIES_PATH}`);
+  }
+  return JSON.parse(readFileSync(COOKIES_PATH, "utf-8"));
+}
+
+function startChrome() {
+  if (chromeProcess) return;
+  chromeProcess = spawn(
+    CHROME_PATH,
+    [
+      `--remote-debugging-port=${CHROME_DEBUG_PORT}`,
+      "--headless=new",
+      "--disable-gpu",
+      "--no-sandbox",
+      "--disable-dev-shm-usage",
+      "--window-size=1440,900",
+      `--user-data-dir=${CHROME_USER_DATA_DIR}`,
+    ],
+    {
+      detached: true,
+      stdio: "ignore",
+    }
+  );
+  chromeProcess.unref();
+}
+
+async function initBrowser() {
+  if (browser?.connected) return browser;
+  if (initializing) return initializing;
+
+  initializing = (async () => {
+    startChrome();
+    await sleep(5000);
+
+    browser = await puppeteer.connect({
+      browserURL: `http://127.0.0.1:${CHROME_DEBUG_PORT}`,
+      defaultViewport: null,
+    });
+
+    browser.on("disconnected", () => {
+      browser = null;
+      sessions.clear();
+    });
+
+    return browser;
+  })();
+
+  try {
+    return await initializing;
+  } finally {
+    initializing = null;
+  }
+}
+
+async function preparePage(page) {
+  const cookies = loadCookies();
+  await page.setUserAgent(
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36"
+  );
+  await page.goto(CHATGPT_URL, {
+    waitUntil: "networkidle2",
+    timeout: 60000,
+  });
+  await page.setCookie(...cookies);
+  await page.reload({
+    waitUntil: "networkidle2",
+    timeout: 60000,
+  });
+  await page.waitForSelector("#prompt-textarea", {
+    visible: true,
+    timeout: 60000,
+  });
+}
+
+async function createSession() {
+  if (sessions.size >= MAX_SESSIONS) {
+    const error = new Error(
+      `Maximum sessions reached. Close an existing page or increase MAX_SESSIONS.`
+    );
+    error.status = 429;
+    throw error;
+  }
+
+  return pageCreateLimiter.run(async () => {
+    if (sessions.size >= MAX_SESSIONS) {
+      const error = new Error(
+        `Maximum sessions reached. Close an existing page or increase MAX_SESSIONS.`
+      );
+      error.status = 429;
+      throw error;
+    }
+
+    const activeBrowser = await initBrowser();
+    const page = await activeBrowser.newPage();
+    await preparePage(page);
+
+    const id = randomUUID();
+    sessions.set(id, {
+      id,
+      page,
+      busy: false,
+      createdAt: new Date().toISOString(),
+      lastMessageAt: null,
+    });
+
+    page.on("close", () => sessions.delete(id));
+
+    return sessions.get(id);
+  });
+}
+
+function getSession(id) {
+  const session = sessions.get(id);
+  if (!session) {
+    const error = new Error(`Session not found: ${id}`);
+    error.status = 404;
+    throw error;
+  }
+  return session;
+}
+
+async function waitForAssistantResponse(page, previousAssistantCount) {
+  await page.waitForFunction(
+    (count) =>
+      document.querySelectorAll('[data-message-author-role="assistant"]')
+        .length > count,
+    { timeout: 120000 },
+    previousAssistantCount
+  );
+
+  await page.waitForFunction(
+    () => {
+      const stopButton =
+        document.querySelector('[data-testid="stop-button"]') ||
+        document.querySelector('button[aria-label*="Stop"]');
+      return !stopButton;
+    },
+    { timeout: 180000 }
+  );
+
+  await sleep(1000);
+
+  return page.evaluate(() => {
+    const messages = document.querySelectorAll(
+      '[data-message-author-role="assistant"]'
+    );
+    return messages[messages.length - 1]?.innerText || "No response found";
+  });
+}
+
+async function sendMessage(session, message) {
+  if (session.busy) {
+    const error = new Error("This session is already processing a message");
+    error.status = 409;
+    throw error;
+  }
+
+  session.busy = true;
+
+  try {
+    return await messageLimiter.run(async () => {
+      const { page } = session;
+      const previousAssistantCount = await page.evaluate(
+        () =>
+          document.querySelectorAll('[data-message-author-role="assistant"]')
+            .length
+      );
+
+      await page.click("#prompt-textarea");
+      await page.evaluate(() => {
+        const element = document.querySelector("#prompt-textarea");
+        if (element) element.innerText = "";
+      });
+
+      await page.keyboard.type(message, { delay: 20 });
+
+      await page.waitForFunction(() => {
+        const button = document.querySelector("#composer-submit-button");
+        return button && !button.disabled;
+      });
+
+      await page.click("#composer-submit-button");
+
+      const response = await waitForAssistantResponse(
+        page,
+        previousAssistantCount
+      );
+
+      session.lastMessageAt = new Date().toISOString();
+      return response;
+    });
+  } finally {
+    session.busy = false;
+  }
+}
+
+app.get("/", (req, res) => {
+  res.json({
+    name: "ChatGPT Puppeteer API",
+    limits: {
+      maxSessions: MAX_SESSIONS,
+      maxConcurrentPageCreates: MAX_CONCURRENT_PAGE_CREATES,
+      maxConcurrentMessages: MAX_CONCURRENT_MESSAGES,
+    },
+    endpoints: {
+      health: "GET /health",
+      init: "POST /init",
+      newPage: "POST /pages",
+      sendMessage: "POST /pages/:id/messages",
+      listPages: "GET /pages",
+      closePage: "DELETE /pages/:id",
+      shutdown: "POST /shutdown",
+    },
+  });
+});
+
+app.get("/health", (req, res) => {
+  res.json({
+    ok: true,
+    browserConnected: Boolean(browser?.connected),
+    sessions: sessions.size,
+    limits: {
+      maxSessions: MAX_SESSIONS,
+      maxConcurrentPageCreates: MAX_CONCURRENT_PAGE_CREATES,
+      maxConcurrentMessages: MAX_CONCURRENT_MESSAGES,
+    },
+    activity: {
+      activePageCreates: pageCreateLimiter.active,
+      queuedPageCreates: pageCreateLimiter.queued,
+      activeMessages: messageLimiter.active,
+      queuedMessages: messageLimiter.queued,
+    },
+  });
+});
+
+app.post("/init", async (req, res, next) => {
+  try {
+    await initBrowser();
+    res.json({ ok: true, browserConnected: true });
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post("/pages", async (req, res, next) => {
+  try {
+    const session = await createSession();
+    res.status(201).json({
+      id: session.id,
+      createdAt: session.createdAt,
+      lastMessageAt: session.lastMessageAt,
+      busy: session.busy,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get("/pages", (req, res) => {
+  res.json({
+    pages: [...sessions.values()].map((session) => ({
+      id: session.id,
+      createdAt: session.createdAt,
+      lastMessageAt: session.lastMessageAt,
+      busy: session.busy,
+    })),
+  });
+});
+
+app.post("/pages/:id/messages", async (req, res, next) => {
+  try {
+    const { message } = req.body;
+
+    if (!message || typeof message !== "string") {
+      return res.status(400).json({
+        error: "Request body must include a non-empty string `message`",
+      });
+    }
+
+    const session = getSession(req.params.id);
+    const response = await sendMessage(session, message);
+
+    res.json({
+      id: session.id,
+      message,
+      response,
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.delete("/pages/:id", async (req, res, next) => {
+  try {
+    const session = getSession(req.params.id);
+    await session.page.close();
+    sessions.delete(session.id);
+    res.status(204).send();
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post("/shutdown", async (req, res, next) => {
+  try {
+    for (const session of sessions.values()) {
+      await session.page.close().catch(() => {});
+    }
+
+    sessions.clear();
+
+    if (browser?.connected) {
+      await browser.close();
+    }
+
+    browser = null;
+    res.json({ ok: true });
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.use((error, req, res, next) => {
+  console.error(error);
+  res.status(error.status || 500).json({
+    error: error.message || "Internal server error",
+  });
+});
+
+app.listen(PORT, () => {
+  console.log(`∞ CLI Server running at http://localhost:${PORT}`);
+});