copilot-proxy-web 1.0.0

package/copilot-proxy.js

@@ -0,0 +1,1114 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+const http = require("node:http");
+const { execSync } = require("node:child_process");
+const os = require("node:os");
+const pty = require("node-pty");
+const express = require("express");
+const { stripAnsi } = require("./lib/format");
+const { formatMarkdownEvent } = require("./lib/markdown");
+const { attachWsServer } = require("./lib/ws");
+const { createHookRegistry } = require("./lib/hooks");
+const { parseArgs } = require("./lib/cli");
+const { createApiRouter } = require("./lib/api");
+const { formatTelegramMarkdownEvent, sendWithRetry } = require("./lib/telegram");
+const { TerminalBuffer } = require("./lib/terminal-buffer");
+const { detectProfileFromChunk, filterConversationLines } = require("./lib/conversation-profiles");
+const { rotateLogFile } = require("./lib/log-rotate");
+const { version: appVersion } = require("./package.json");
+
+const argv = process.argv.slice(2);
+const isCli = require.main === module;
+const {
+  logPath,
+  webEnabled,
+  webPlain,
+  apiEnabled,
+  host,
+  port,
+  apiPort,
+  useShell,
+  debugWs,
+  debugWsPath,
+  ptyCols,
+  ptyRows,
+  idleMs,
+  idleLogPath,
+  idleClean,
+  idleMarkdown,
+  idleMarkdownMaxChars,
+  idleBufferMaxChars: cliIdleBufferMaxChars,
+  idleBurstMs: cliIdleBurstMs,
+  idlePacketMaxBytes: cliIdlePacketMaxBytes,
+  conversationContext: cliConversationContext,
+  conversationProfile: cliConversationProfile,
+  tgToken: cliTgToken,
+  tgChat: cliTgChat,
+  tgProxy: cliTgProxy,
+  tgParseMode: cliTgParseMode,
+  tgRetry: cliTgRetry,
+  tgBackoffMs: cliTgBackoffMs,
+  tgTimeoutMs: cliTgTimeoutMs,
+  tgMaxChars: cliTgMaxChars,
+  authToken: cliAuthToken,
+  useXForwardedFor: cliUseXForwardedFor,
+  enforceAuthOnPublic: cliEnforceAuthOnPublic,
+  noDefaultSession,
+  noStdin,
+  noStdout,
+  cmd,
+  args,
+} = parseArgs(argv);
+
+function readEnvNumber(value) {
+  if (value === undefined || value === null || value === "") return null;
+  const num = Number(value);
+  return Number.isFinite(num) ? num : null;
+}
+
+const tgToken = cliTgToken ?? process.env.TG_TOKEN ?? "";
+const tgChat = cliTgChat ?? process.env.TG_CHAT ?? "";
+const tgProxy = cliTgProxy ?? process.env.TG_PROXY ?? "";
+const tgParseMode = (cliTgParseMode ?? process.env.TG_PARSE_MODE ?? "MarkdownV2");
+const tgRetry = cliTgRetry ?? readEnvNumber(process.env.TG_RETRY) ?? 2;
+const tgBackoffMs = cliTgBackoffMs ?? readEnvNumber(process.env.TG_BACKOFF_MS) ?? 1000;
+const tgTimeoutMs = cliTgTimeoutMs ?? readEnvNumber(process.env.TG_TIMEOUT_MS) ?? 10000;
+const tgMaxChars = cliTgMaxChars ?? readEnvNumber(process.env.TG_MAX_CHARS) ?? 3500;
+const idleBufferMaxChars = cliIdleBufferMaxChars ?? readEnvNumber(process.env.IDLE_BUFFER_MAX_CHARS) ?? 20000;
+const idleBurstMs = cliIdleBurstMs ?? readEnvNumber(process.env.IDLE_BURST_MS) ?? 200;
+const idlePacketMaxBytes = cliIdlePacketMaxBytes
+  ?? readEnvNumber(process.env.IDLE_PACKET_MAX_BYTES)
+  ?? 128;
+const conversationContext = cliConversationContext
+  ?? readEnvNumber(process.env.CONVERSATION_CONTEXT)
+  ?? 1;
+const conversationProfile = (cliConversationProfile ?? process.env.CONVERSATION_PROFILE ?? "none")
+  .toString()
+  .toLowerCase();
+const tgEnabled = Boolean(tgToken && tgChat);
+const authToken = cliAuthToken ?? process.env.AUTH_TOKEN ?? "";
+const useXForwardedFor = Boolean(
+  cliUseXForwardedFor || /^(1|true|yes|on)$/i.test(String(process.env.USE_X_FORWARDED_FOR || ""))
+);
+const enforceAuthOnPublic = Boolean(
+  cliEnforceAuthOnPublic || /^(1|true|yes|on)$/i.test(String(process.env.ENFORCE_AUTH_ON_PUBLIC || ""))
+);
+const accessLogMode = (process.env.ACCESS_LOG_MODE || "auth").toLowerCase();
+const logRotateMaxBytes =
+  readEnvNumber(process.env.LOG_ROTATE_MAX_BYTES) ?? 10 * 1024 * 1024;
+const logRotateRetainDays =
+  readEnvNumber(process.env.LOG_ROTATE_RETAIN_DAYS) ?? 14;
+
+let logDir = null;
+let logFile = null;
+let accessLogFile = null;
+if (isCli) {
+  const resolved = path.resolve(logPath);
+  try {
+    const stat = fs.statSync(resolved);
+    if (stat.isDirectory()) {
+      logDir = resolved;
+    } else {
+      logFile = resolved;
+      logDir = path.dirname(resolved);
+    }
+  } catch {
+    if (logPath.endsWith(path.sep)) {
+      logDir = resolved;
+    } else {
+      logFile = resolved;
+      logDir = path.dirname(resolved);
+    }
+  }
+  if (logDir) {
+    fs.mkdirSync(logDir, { recursive: true });
+    accessLogFile = path.join(logDir, "access.log");
+  }
+}
+
+if (isCli && logFile) {
+  rotateLogFile(logFile, {
+    maxBytes: logRotateMaxBytes,
+    retainDays: logRotateRetainDays,
+  });
+}
+if (isCli && idleLogPath) {
+  rotateLogFile(path.resolve(idleLogPath), {
+    maxBytes: logRotateMaxBytes,
+    retainDays: logRotateRetainDays,
+  });
+}
+if (debugWs && debugWsPath) {
+  rotateLogFile(path.resolve(debugWsPath), {
+    maxBytes: logRotateMaxBytes,
+    retainDays: logRotateRetainDays,
+  });
+}
+if (isCli && accessLogFile) {
+  rotateLogFile(accessLogFile, {
+    maxBytes: logRotateMaxBytes,
+    retainDays: logRotateRetainDays,
+  });
+}
+
+const logStream = isCli && logFile
+  ? fs.createWriteStream(logFile, { flags: "a" })
+  : null;
+const accessLogStream = isCli && accessLogFile
+  ? fs.createWriteStream(accessLogFile, { flags: "a" })
+  : null;
+const debugStream = debugWs
+  ? (debugWsPath
+      ? fs.createWriteStream(path.resolve(debugWsPath), { flags: "a" })
+      : process.stdout)
+  : null;
+const idleLogStream = isCli && idleLogPath
+  ? fs.createWriteStream(path.resolve(idleLogPath), { flags: "a" })
+  : null;
+
+function logEvent(message) {
+  if (!isCli) return;
+  const ts = new Date().toISOString();
+  process.stdout.write(`[${ts}] ${message}\n`);
+}
+
+function logAccess(payload) {
+  if (!accessLogStream) return;
+  const record = {
+    ts: new Date().toISOString(),
+    ...payload,
+  };
+  accessLogStream.write(`${JSON.stringify(record)}\n`);
+}
+
+function resolveExecutable(bin) {
+  if (bin.includes("/")) return 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 bin;
+}
+
+function shellQuote(arg) {
+  if (arg === "") return "''";
+  if (/^[A-Za-z0-9_./:-]+$/.test(arg)) return arg;
+  return `'${arg.replace(/'/g, `'\"'\"'`)}'`;
+}
+
+const MAX_HISTORY = 2000;
+const MAX_HOOK_EVENTS = 50;
+const DEFAULT_SESSION_ID = "default";
+
+function buildSpawnCommand(runCmd, runArgs, runShell, runShellInteractive) {
+  let spawnCmd = runCmd;
+  let spawnArgs = runArgs;
+  const shouldShell = Boolean(runShell ?? useShell);
+  if (shouldShell) {
+    const shell = process.env.SHELL || "/bin/zsh";
+    let joined = "";
+    if (!runArgs || runArgs.length === 0) {
+      // treat runCmd as a full command line when no args are provided
+      joined = String(runCmd || "");
+    } else {
+      joined = [runCmd, ...runArgs].map(shellQuote).join(" ");
+    }
+    spawnCmd = shell;
+    const shellMode = runShellInteractive ? "-lic" : "-lc";
+    spawnArgs = [shellMode, joined];
+  }
+  const resolvedCmd = resolveExecutable(spawnCmd);
+  return { spawnCmd: resolvedCmd, spawnArgs };
+}
+
+function spawnTerm(
+  runCmd,
+  runArgs,
+  runCwd,
+  runShell,
+  runShellInteractive,
+  colsOverride,
+  rowsOverride
+) {
+  const { spawnCmd, spawnArgs } = buildSpawnCommand(runCmd, runArgs, runShell, runShellInteractive);
+  return pty.spawn(spawnCmd, spawnArgs, {
+    name: "xterm-256color",
+    cols: colsOverride || process.stdout.columns || ptyCols || 80,
+    rows: rowsOverride || process.stdout.rows || ptyRows || 24,
+    cwd: runCwd || process.cwd(),
+    env: process.env,
+  });
+}
+
+function createSessionManager(options = {}) {
+  const {
+    spawn = spawnTerm,
+    stdout = noStdout ? null : process.stdout,
+    log = logStream,
+    idleLog = idleLogStream,
+    idleMs: idleMsOverride,
+    idleBurstMs: idleBurstMsOverride,
+    idlePacketMaxBytes: idlePacketMaxBytesOverride,
+  } = options;
+  const effectiveIdleMs = Number.isFinite(idleMsOverride) ? idleMsOverride : idleMs;
+  const effectiveIdleBurstMs = Number.isFinite(idleBurstMsOverride)
+    ? idleBurstMsOverride
+    : idleBurstMs;
+  let effectiveIdlePacketMaxBytes = Number.isFinite(idlePacketMaxBytesOverride)
+    ? idlePacketMaxBytesOverride
+    : idlePacketMaxBytes;
+  const sessions = new Map();
+  const MAX_CONVERSATION_EVENTS = 200;
+
+  function canonicalizeConversationText(value) {
+    const lines = String(value || "")
+      .split("\n")
+      .map((line) => line.trimEnd())
+      .map((line) => {
+        // Copilot spinner glyph changes frequently while content stays identical.
+        if (/^\s*[◐◑◒◓◎◉∙•●]\s+Thinking \(Esc to cancel/.test(line)) {
+          return line.replace(/^\s*[◐◑◒◓◎◉∙•●]\s+/, "Thinking ");
+        }
+        return line;
+      })
+      .filter(Boolean);
+    return lines.join("\n").replace(/\s+/g, " ").trim();
+  }
+
+  function emitSession(session, event) {
+    const payload = { ...event, sessionId: session.id };
+    session.hookEvents.push(payload);
+    if (session.hookEvents.length > MAX_HOOK_EVENTS) {
+      session.hookEvents.splice(0, session.hookEvents.length - MAX_HOOK_EVENTS);
+    }
+    session.hookRegistry.emit(payload);
+    for (const res of session.sseClients) {
+      res.write(`data: ${JSON.stringify(payload)}\n\n`);
+    }
+  }
+
+  function idleStart(session) {
+    session.idleActive = true;
+    session.idleBuffer = "";
+    emitSession(session, { type: "thinking_start", ts: new Date().toISOString() });
+  }
+
+  function idleEnd(session) {
+    if (!session.idleActive) return;
+    session.idleActive = false;
+    emitSession(session, {
+      type: "thinking_end",
+      ts: new Date().toISOString(),
+      content: session.idleBuffer,
+    });
+    session.idleBuffer = "";
+  }
+
+  function broadcast(session, text) {
+    for (const ws of session.clients) {
+      if (ws.readyState === 1) {
+        ws.send(text);
+      }
+    }
+  }
+
+  function normalizeConversationText(text, { skipPromptCrop = false, profile = "none" } = {}) {
+    const stripped = stripAnsi(text || "");
+    const cleaned = stripped
+      .replace(/\r\n/g, "\n")
+      .replace(/\r/g, "\n")
+      .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "")
+      .replace(/\[\?[0-9A-Za-z;?\\]+/g, "")
+      .trim();
+    const rawLines = cleaned.split("\n");
+    const lines = [];
+    let lastLine = "";
+    let lastPrompt = "";
+    let sincePrompt = 0;
+    const isSeparatorLine = (value) => /^[─━\-]+$/.test(value.replace(/\s+/g, ""));
+    for (const line of rawLines) {
+      const trimmed = line.replace(/[\u200B-\u200D\uFEFF]/g, "").trimEnd();
+      if (trimmed === lastLine) continue;
+      const isSeparator = isSeparatorLine(trimmed);
+      if (isSeparator && lastLine && /^[─━\-]+$/.test(lastLine.replace(/\s+/g, ""))) {
+        continue;
+      }
+      const isPrompt = trimmed.includes("Type @ to mention files") || trimmed.startsWith("❯ ");
+      if (isPrompt) {
+        if (lastPrompt === trimmed && sincePrompt < 6) {
+          sincePrompt += 1;
+          continue;
+        }
+        lastPrompt = trimmed;
+        sincePrompt = 0;
+      } else {
+        sincePrompt += 1;
+      }
+      lines.push(trimmed);
+      lastLine = trimmed;
+    }
+    let focused = lines;
+    if (!skipPromptCrop) {
+      const promptIdx = [];
+      for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (line.includes("Type @ to mention files") || line.startsWith("❯ ")) {
+          promptIdx.push(i);
+        }
+      }
+      let start = 0;
+      if (promptIdx.length >= 2) {
+        start = promptIdx[promptIdx.length - 2];
+      } else if (promptIdx.length === 1) {
+        start = Math.max(0, promptIdx[0] - 2);
+      }
+      focused = lines.slice(start);
+    }
+    focused = filterConversationLines(focused, profile);
+    const maxLines = 120;
+    const sliced = focused.length > maxLines ? focused.slice(-maxLines) : focused;
+    const textOut = sliced.join("\n").trim();
+    const keyLines = sliced
+      .map((l) => l.replace(/\s+/g, " ").trim())
+      .filter(
+        (l) =>
+          l &&
+          !l.includes("Type @ to mention files") &&
+          !l.startsWith("❯") &&
+          !/^[─━\-]+$/.test(l.replace(/\s+/g, ""))
+      );
+    const key = keyLines.join("\n");
+    return { text: textOut, key };
+  }
+
+  function diffLines(prevLines, nextLines) {
+    if (!prevLines || prevLines.length === 0) return nextLines;
+    const maxOverlap = Math.min(prevLines.length, nextLines.length);
+    for (let overlap = maxOverlap; overlap >= 1; overlap -= 1) {
+      const prevSlice = prevLines.slice(-overlap);
+      for (let i = 0; i <= nextLines.length - overlap; i += 1) {
+        let match = true;
+        for (let j = 0; j < overlap; j += 1) {
+          if (nextLines[i + j] !== prevSlice[j]) {
+            match = false;
+            break;
+          }
+        }
+        if (match) {
+          return nextLines.slice(i + overlap);
+        }
+      }
+    }
+    return nextLines;
+  }
+
+  function getScreenDelta(session) {
+    if (!session.screen) return null;
+    const dirty = session.screen.consumeDirtyLines();
+    if (!dirty.length) return { delta: [] };
+    const ctx = Math.max(0, Number.isFinite(conversationContext) ? conversationContext : 0);
+    const rows = dirty.map((item) => item.row);
+    const minRow = Math.min(...rows);
+    const maxRow = Math.max(...rows);
+    const start = Math.max(0, minRow - ctx);
+    const end = Math.min(session.screen.rows - 1, maxRow + ctx);
+    const delta = [];
+    for (let r = start; r <= end; r += 1) {
+      const line = session.screen.getRow(r);
+      delta.push(line);
+    }
+    return {
+      delta,
+      startRow: start,
+      endRow: end,
+      dirtyRows: rows.slice().sort((a, b) => a - b),
+    };
+  }
+
+  function setupHooks(session) {
+    session.hookRegistry.addHook((event) => {
+      if (event.type === "thinking_start") {
+        return;
+      }
+      if (event.type !== "thinking_end") return;
+      let normalized = { text: "", key: "" };
+      const screenDelta = getScreenDelta(session);
+      if (screenDelta && screenDelta.delta.length) {
+        normalized = normalizeConversationText(screenDelta.delta.join("\n"), {
+          skipPromptCrop: true,
+          profile: session.detectedProfile || session.conversationProfile || "none",
+        });
+      } else {
+        normalized = normalizeConversationText(event.content || "", {
+          profile: session.detectedProfile || session.conversationProfile || "none",
+        });
+      }
+      if (!normalized.text) return;
+      addConversationEvent(session, {
+        role: "assistant",
+        markdown: normalized.text,
+        ts: new Date().toISOString(),
+        meta: {
+          source: "idle",
+          status: "final",
+          format: "terminal",
+          key: normalized.key,
+          rows:
+            screenDelta && Number.isFinite(screenDelta.startRow) && Number.isFinite(screenDelta.endRow)
+              ? {
+                  start: screenDelta.startRow + 1,
+                  end: screenDelta.endRow + 1,
+                  dirty: Array.isArray(screenDelta.dirtyRows)
+                    ? screenDelta.dirtyRows.map((r) => r + 1)
+                    : [],
+                }
+              : null,
+        },
+      });
+    });
+    if (idleLog) {
+      session.hookRegistry.addHook((event) => {
+        if (idleMarkdown) {
+          const parts = formatMarkdownEvent(event, {
+            info: "text",
+            maxChars: idleMarkdownMaxChars,
+            clean: idleClean,
+          });
+          for (const part of parts) {
+            idleLog.write(part);
+          }
+          return;
+        }
+        if (event.type === "thinking_start") {
+          idleLog.write(`\n[IDLE_START] ${event.ts}\n`);
+          return;
+        }
+        if (event.type === "thinking_end") {
+          if (event.content) idleLog.write(event.content);
+          idleLog.write(`\n[IDLE_END] ${event.ts}\n`);
+        }
+      });
+    }
+
+    if (tgEnabled) {
+      session.hookRegistry.addHook((event) => {
+        if (event.type !== "thinking_end") return;
+        const parts = formatTelegramMarkdownEvent(event, { maxChars: tgMaxChars });
+        (async () => {
+          for (const text of parts) {
+            await sendWithRetry(
+              {
+                token: tgToken,
+                chatId: tgChat,
+                text,
+                parseMode: tgParseMode,
+                proxy: tgProxy,
+                timeoutMs: tgTimeoutMs,
+              },
+              tgRetry,
+              tgBackoffMs
+            );
+          }
+        })().catch(() => {
+          // ignore telegram errors in hook pipeline
+        });
+      });
+    }
+  }
+
+  function cleanupSession(session, { kill } = { kill: true }) {
+    if (session.idleTimer) clearTimeout(session.idleTimer);
+    for (const ws of session.clients) {
+      try {
+        ws.close();
+      } catch {
+        // ignore
+      }
+    }
+    for (const res of session.sseClients) {
+      try {
+        res.end();
+      } catch {
+        // ignore
+      }
+    }
+    if (kill && session.term) {
+      try {
+        session.term.kill();
+      } catch {
+        // ignore
+      }
+    }
+    if (session.inputLog) session.inputLog.end();
+    if (session.outputLog) session.outputLog.end();
+    logEvent(`session_cleanup id=${session.id} killed=${kill} pid=${session.pid ?? "n/a"}`);
+  }
+
+  function attachTerm(session, runCmd, runArgs, runCwd, runShell, runShellInteractive) {
+    const cols = session.initialCols || ptyCols;
+    const rows = session.initialRows || ptyRows;
+    const term = spawn(
+      runCmd || cmd,
+      runArgs || args,
+      runCwd,
+      runShell,
+      runShellInteractive,
+      cols,
+      rows
+    );
+    session.term = term;
+    session.pid = term.pid;
+    if (logDir) {
+      const inputLogPath = path.join(logDir, `session-${session.id}.input.log`);
+      const outputLogPath = path.join(logDir, `session-${session.id}.output.log`);
+      rotateLogFile(inputLogPath, {
+        maxBytes: logRotateMaxBytes,
+        retainDays: logRotateRetainDays,
+      });
+      rotateLogFile(outputLogPath, {
+        maxBytes: logRotateMaxBytes,
+        retainDays: logRotateRetainDays,
+      });
+      session.inputLog = fs.createWriteStream(
+        inputLogPath,
+        { flags: "a" }
+      );
+      session.outputLog = fs.createWriteStream(
+        outputLogPath,
+        { flags: "a" }
+      );
+      fs.writeFileSync(
+        path.join(logDir, `session-${session.id}.pid`),
+        String(session.pid || "")
+      );
+    }
+    session.writeInput = (data) => {
+      if (session.inputLog) session.inputLog.write(data);
+      emitSession(session, { type: "raw_input", ts: new Date().toISOString(), content: data });
+      term.write(data);
+    };
+    term.on("data", (data) => {
+      if (stdout) stdout.write(data);
+      if (log) log.write(data);
+      if (session.outputLog) session.outputLog.write(data);
+      if (session.screen) {
+        session.screen.write(data);
+        // Auto profile detection is disabled by default; users choose profile explicitly.
+        if (
+          session.conversationProfile === "auto" &&
+          !session.detectedProfile &&
+          detectProfileFromChunk(data, session.copilotDetectState)
+        ) {
+          session.detectedProfile = "copilot";
+          addConversationEvent(session, {
+            role: "assistant",
+            markdown: "[conversation profile] GitHub Copilot CLI",
+            ts: new Date().toISOString(),
+            meta: { source: "system", format: "text" },
+          });
+        }
+      }
+      session.lastOutputTs = Date.now();
+      emitSession(session, { type: "raw_output", ts: new Date().toISOString(), content: data });
+      const payload = webPlain ? stripAnsi(data) : data;
+      if (webEnabled) {
+        session.history.push(payload);
+        if (session.history.length > MAX_HISTORY) {
+          session.history.splice(0, session.history.length - MAX_HISTORY);
+        }
+        broadcast(session, payload);
+      }
+      if (!session.idleActive) {
+        idleStart(session);
+      }
+      if (session.idleTimer) {
+        clearTimeout(session.idleTimer);
+      }
+      const idleChunk = idleClean ? stripAnsi(data) : data;
+      session.idleBuffer += idleChunk;
+      if (Number.isFinite(idleBufferMaxChars) && idleBufferMaxChars > 0) {
+        if (session.idleBuffer.length > idleBufferMaxChars) {
+          session.idleBuffer = session.idleBuffer.slice(-idleBufferMaxChars);
+        }
+      }
+      const chunkLength = typeof data === "string" ? data.length : 0;
+      if (
+        Number.isFinite(chunkLength) &&
+        chunkLength > 0 &&
+        (!Number.isFinite(effectiveIdlePacketMaxBytes) || chunkLength > effectiveIdlePacketMaxBytes)
+      ) {
+        effectiveIdlePacketMaxBytes = chunkLength;
+      }
+      let idleTimeout = effectiveIdleMs;
+      if (
+        Number.isFinite(effectiveIdlePacketMaxBytes) &&
+        effectiveIdlePacketMaxBytes > 0 &&
+        chunkLength > 0 &&
+        chunkLength < effectiveIdlePacketMaxBytes &&
+        Number.isFinite(effectiveIdleBurstMs) &&
+        effectiveIdleBurstMs > 0
+      ) {
+        idleTimeout = Math.min(effectiveIdleMs, effectiveIdleBurstMs);
+      }
+      session.idleTimer = setTimeout(() => {
+        idleEnd(session);
+      }, idleTimeout);
+    });
+
+    term.on("exit", (code) => {
+      cleanupSession(session, { kill: false });
+      session.term = null;
+      session.pid = null;
+      logEvent(`session_exit id=${session.id} code=${code ?? "n/a"}`);
+      if (session.exitOnClose) {
+        process.exit(code ?? 0);
+      }
+    });
+  }
+
+  function createSession({
+    id,
+    cmd: runCmd,
+    args: runArgs,
+    cwd: runCwd,
+    shell: runShell,
+    shellInteractive: runShellInteractive,
+    conversationProfile: runConversationProfile,
+    autoStart = true,
+  } = {}) {
+    const sessionId =
+      id || `s-${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
+    if (sessions.has(sessionId)) return sessions.get(sessionId);
+    const session = {
+      id: sessionId,
+      term: null,
+      pid: null,
+      initialCols: ptyCols,
+      initialRows: ptyRows,
+      inputLog: null,
+      outputLog: null,
+      writeInput: null,
+      cmd: runCmd || cmd,
+      args: runArgs || args,
+      cwd: runCwd || process.cwd(),
+      shell: runShell === undefined ? undefined : Boolean(runShell),
+      shellInteractive:
+        runShellInteractive === undefined ? undefined : Boolean(runShellInteractive),
+      exitOnClose: false,
+      history: [],
+      clients: new Set(),
+      sseClients: new Set(),
+      hookRegistry: createHookRegistry({
+        onError(err, event) {
+          session.hookErrors.push({
+            ts: new Date().toISOString(),
+            message: err?.message || "hook error",
+            type: event?.type || "unknown",
+          });
+          if (session.hookErrors.length > MAX_HOOK_EVENTS) {
+            session.hookErrors.splice(0, session.hookErrors.length - MAX_HOOK_EVENTS);
+          }
+        },
+      }),
+      hookEvents: [],
+      hookErrors: [],
+      conversation: [],
+      conversationSeq: 0,
+      screen: new TerminalBuffer(ptyCols, ptyRows),
+      lastScreenLines: [],
+      conversationProfile: (() => {
+        const raw = String(runConversationProfile || conversationProfile || "none").toLowerCase();
+        if (raw === "off" || raw === "auto") return "none";
+        if (raw !== "copilot") return "none";
+        return raw;
+      })(),
+      detectedProfile: "",
+      copilotDetectState: {
+        seenVersion: false,
+        seenPrompt: false,
+      },
+      idleTimer: null,
+      idleBuffer: "",
+      idleActive: false,
+      lastOutputTs: null,
+      createdAt: Date.now(),
+    };
+
+    setupHooks(session);
+    if (session.conversationProfile && session.conversationProfile !== "none") {
+      addConversationEvent(session, {
+        role: "assistant",
+        markdown: `[conversation profile] ${session.conversationProfile}`,
+        ts: new Date().toISOString(),
+        meta: { source: "system", format: "text" },
+      });
+    }
+    if (autoStart) {
+      session.exitOnClose = session.id === DEFAULT_SESSION_ID && !noDefaultSession;
+      attachTerm(
+        session,
+        session.cmd,
+        session.args,
+        session.cwd,
+        session.shell,
+        session.shellInteractive
+      );
+    }
+
+    sessions.set(sessionId, session);
+    logEvent(
+      `session_create id=${session.id} autoStart=${autoStart} cmd=${session.cmd} cwd=${session.cwd}`
+    );
+    return session;
+  }
+
+  function addConversationEvent(session, event) {
+    if (!session) return;
+    const entry = {
+      seq: (session.conversationSeq || 0) + 1,
+      role: event.role || "assistant",
+      markdown: event.markdown || "",
+      ts: event.ts || new Date().toISOString(),
+      sessionId: session.id,
+      meta: event.meta || null,
+    };
+    if (entry.role === "assistant" && entry.meta?.format === "terminal") {
+      const last = session.conversation[session.conversation.length - 1];
+      const normalizeBlock = (value) =>
+        String(value || "")
+          .replace(/\s+/g, " ")
+          .trim();
+      const normalizeLines = (value) =>
+        String(value || "")
+          .split("\n")
+          .map((line) => line.trim())
+          .filter(Boolean);
+      if (
+        last &&
+        last.role === "assistant" &&
+        last.meta?.format === "terminal" &&
+        (last.meta?.key && entry.meta?.key && last.meta.key === entry.meta.key)
+      ) {
+        return;
+      }
+      const lastText = last ? normalizeBlock(last.markdown) : "";
+      const nextText = normalizeBlock(entry.markdown);
+      if (lastText && nextText && lastText.includes(nextText)) {
+        return;
+      }
+      if (last?.meta?.key && entry.meta?.key) {
+        const lastLines = normalizeLines(last.meta.key);
+        const nextLines = normalizeLines(entry.meta.key);
+        if (lastLines.length && nextLines.length) {
+          const lastSet = new Set(lastLines);
+          const isSubset = nextLines.every((line) => lastSet.has(line));
+          if (isSubset) return;
+        }
+      }
+      if (entry.meta?.key && entry.meta.key.length < 8) {
+        return;
+      }
+      const normalized = normalizeBlock(entry.markdown);
+      if (normalized && session.lastConversationText === normalized) {
+        return;
+      }
+      const canonical = canonicalizeConversationText(entry.markdown);
+      if (canonical && session.lastConversationCanonical === canonical) {
+        return;
+      }
+      session.lastConversationText = normalized || session.lastConversationText;
+      session.lastConversationCanonical = canonical || session.lastConversationCanonical;
+      session.lastConversationLines = normalizeLines(event.markdown);
+    }
+    session.conversationSeq = entry.seq;
+    session.conversation.push(entry);
+    if (session.conversation.length > MAX_CONVERSATION_EVENTS) {
+      session.conversation.splice(0, session.conversation.length - MAX_CONVERSATION_EVENTS);
+    }
+  }
+
+  function getSession(id) {
+    return sessions.get(id);
+  }
+
+  function getDefaultSession() {
+    return sessions.get(DEFAULT_SESSION_ID);
+  }
+
+  function listSessions() {
+    return Array.from(sessions.values()).map((session) => ({
+      id: session.id,
+      started: Boolean(session.term),
+      cmd: session.cmd,
+      args: session.args,
+      cwd: session.cwd,
+      cols: session.term?.cols || session.initialCols || ptyCols,
+      rows: session.term?.rows || session.initialRows || ptyRows,
+      initialCols: session.initialCols || ptyCols,
+      initialRows: session.initialRows || ptyRows,
+      idleActive: session.idleActive,
+      lastOutputTs: session.lastOutputTs,
+      createdAt: session.createdAt,
+      hookErrorCount: session.hookErrors.length,
+      conversationProfile: session.detectedProfile || session.conversationProfile || "none",
+    }));
+  }
+
+  function deleteSession(id) {
+    const session = sessions.get(id);
+    if (!session) return false;
+    sessions.delete(id);
+    cleanupSession(session, { kill: true });
+    logEvent(`session_delete id=${id}`);
+    return true;
+  }
+
+  function startSession(
+    id,
+    {
+      cmd: runCmd,
+      args: runArgs,
+      cwd: runCwd,
+      shell: runShell,
+      shellInteractive: runShellInteractive,
+      conversationProfile: runConversationProfile,
+    } = {}
+  ) {
+    const session = sessions.get(id);
+    if (!session) return null;
+    if (session.term) return session;
+    session.cmd = runCmd || session.cmd || cmd;
+    session.args = runArgs || session.args || args;
+    session.cwd = runCwd || session.cwd || process.cwd();
+    if (runShell !== undefined) {
+      session.shell = Boolean(runShell);
+    }
+    if (runShellInteractive !== undefined) {
+      session.shellInteractive = Boolean(runShellInteractive);
+    }
+    if (runConversationProfile !== undefined) {
+      const raw = String(runConversationProfile || "").toLowerCase() || "none";
+      session.conversationProfile =
+        raw === "copilot" ? "copilot" : "none";
+      session.detectedProfile = "";
+      session.copilotDetectState = {
+        seenVersion: false,
+        seenPrompt: false,
+      };
+      if (session.conversationProfile !== "none") {
+        addConversationEvent(session, {
+          role: "assistant",
+          markdown: `[conversation profile] ${session.conversationProfile}`,
+          ts: new Date().toISOString(),
+          meta: { source: "system", format: "text" },
+        });
+      }
+    }
+    attachTerm(
+      session,
+      session.cmd,
+      session.args,
+      session.cwd,
+      session.shell,
+      session.shellInteractive
+    );
+    logEvent(`session_start id=${session.id} cmd=${session.cmd} cwd=${session.cwd}`);
+    return session;
+  }
+
+  let didShutdown = false;
+  function shutdown() {
+    if (didShutdown) return;
+    didShutdown = true;
+    for (const session of sessions.values()) {
+      cleanupSession(session, { kill: true });
+    }
+    sessions.clear();
+    logEvent("shutdown");
+  }
+
+  if (!noDefaultSession) {
+    createSession({ id: DEFAULT_SESSION_ID, autoStart: true });
+  }
+
+  return {
+    createSession,
+    getSession,
+    getDefaultSession,
+    listSessions,
+    deleteSession,
+    startSession,
+    addConversationEvent,
+    shutdown,
+    sessions,
+  };
+}
+
+const sessionManager = isCli ? createSessionManager() : null;
+
+function restoreStdin() {
+  if (process.stdin.isTTY) {
+    try {
+      process.stdin.setRawMode(false);
+    } catch {
+      // ignore
+    }
+  }
+  if (process.stdin.isTTY && process.platform !== "win32") {
+    try {
+      execSync("stty sane", { stdio: "ignore" });
+    } catch {
+      // ignore
+    }
+  }
+}
+
+module.exports = {
+  createSessionManager,
+};
+
+if (isCli) {
+  if (!noStdin) {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.on("data", (data) => {
+      if (data && data.includes && data.includes("\u0003")) {
+        sessionManager.shutdown();
+        restoreStdin();
+        process.exit(0);
+      }
+      const session = sessionManager.getDefaultSession();
+      if (session && session.term) {
+        if (session.writeInput) session.writeInput(data);
+        else session.term.write(data);
+      }
+    });
+  }
+
+  process.on("SIGINT", () => {
+    sessionManager.shutdown();
+    restoreStdin();
+    process.exit(0);
+  });
+
+  process.stdout.on("resize", () => {
+    for (const session of sessionManager.sessions.values()) {
+      if (session.term) {
+        const cols = process.stdout.columns || 80;
+        const rows = process.stdout.rows || 24;
+        session.term.resize(cols, rows);
+        if (session.screen) session.screen.resize(cols, rows);
+      }
+    }
+  });
+}
+
+let webServer;
+let apiServer;
+let wss;
+
+if (isCli && (webEnabled || apiEnabled)) {
+  const isLoopbackHost =
+    host === "127.0.0.1" || host === "localhost" || host === "::1";
+  logEvent(`Version: v${appVersion}`);
+  if (authToken) {
+    logEvent("Auth: enabled (token required)");
+  }
+  logEvent(`Use X-Forwarded-For: ${useXForwardedFor ? "enabled" : "disabled"}`);
+  if (!authToken) {
+    logEvent("Auth: disabled");
+    logEvent(
+      "WARNING: AUTH_TOKEN not set; API/WS are unauthenticated. Use --auth-token or AUTH_TOKEN env."
+    );
+    if (!isLoopbackHost) {
+      logEvent(
+        `WARNING: host=${host} is not loopback; unauthenticated API/WS may be exposed.`
+      );
+      if (enforceAuthOnPublic) {
+        logEvent(
+          "FATAL: --enforce-auth-on-public is enabled and AUTH_TOKEN is missing for non-loopback host."
+        );
+        process.exit(1);
+      }
+    }
+  }
+  const apiRouter = createApiRouter({
+    sessionManager,
+    idleMs: () => idleMs,
+    webEnabled: () => webEnabled,
+    apiEnabled: () => apiEnabled,
+    version: appVersion,
+    user: os.userInfo().username,
+    authToken,
+    useXForwardedFor,
+    accessLog: logAccess,
+    accessLogMode,
+  });
+  const publicDir = path.join(__dirname, "public");
+
+  if (webEnabled) {
+    const webApp = express();
+    webApp.use(express.json({ limit: "1mb" }));
+    webApp.use(express.static(publicDir));
+    if (apiEnabled && apiPort === port) {
+      webApp.use(apiRouter);
+    }
+
+    webServer = http.createServer(webApp);
+    wss = attachWsServer({
+      server: webServer,
+      sessionManager,
+      debugWs,
+      debugStream,
+      authToken,
+      useXForwardedFor,
+      accessLog: logAccess,
+      accessLogMode,
+    });
+
+    webServer.listen(port, host, () => {
+      logEvent(`Web UI listening on http://${host}:${port}`);
+      if (apiEnabled && apiPort === port) {
+        logEvent(`API listening on http://${host}:${port}/api`);
+      }
+    });
+  }
+
+  if (apiEnabled && (!webEnabled || apiPort !== port)) {
+    const apiApp = express();
+    apiApp.use(express.json({ limit: "1mb" }));
+    apiApp.use(apiRouter);
+    apiServer = http.createServer(apiApp);
+    apiServer.listen(apiPort, host, () => {
+      logEvent(`API listening on http://${host}:${apiPort}/api`);
+    });
+  }
+}
+
+if (isCli) {
+  process.on("exit", () => {
+    sessionManager.shutdown();
+    restoreStdin();
+    if (logStream) logStream.end();
+    if (accessLogStream) accessLogStream.end();
+    if (idleLogStream) idleLogStream.end();
+    if (debugStream && debugStream !== process.stdout) {
+      debugStream.end();
+    }
+    if (wss) wss.close();
+    if (webServer) webServer.close();
+    if (apiServer) apiServer.close();
+  });
+}