copilot-proxy-web 1.0.0

package/lib/daemon-service.js

@@ -0,0 +1,210 @@
+function createDaemonService({
+  daemonStateStore,
+  buildArgs,
+  spawnFn,
+  isProcessAlive,
+  sleepFn,
+  processLike,
+  consoleLike,
+  httpLike,
+  resolveHostForPrint,
+  resolveApiPortForPrint,
+  hasAuthConfigured,
+  port,
+  log,
+  ptyCols,
+  ptyRows,
+  noDefaultSession,
+  noStdin,
+  noStdout,
+  passthrough,
+  restoreTerminal,
+}) {
+  function runForeground() {
+    const child = spawnFn(processLike.execPath, buildArgs(), { stdio: "inherit" });
+    processLike.on("SIGINT", () => {
+      restoreTerminal();
+    });
+    child.on("exit", (code, signal) => {
+      restoreTerminal();
+      if (signal) {
+        processLike.kill(processLike.pid, signal);
+        return;
+      }
+      processLike.exit(code ?? 0);
+    });
+  }
+
+  function startBackground() {
+    const existingPid = daemonStateStore.readPid();
+    if (existingPid && isProcessAlive(existingPid)) {
+      consoleLike.log(`Already running (pid ${existingPid}).`);
+      processLike.exit(0);
+      return;
+    }
+    if (existingPid && !isProcessAlive(existingPid)) {
+      daemonStateStore.clearPid();
+    }
+    const child = spawnFn(processLike.execPath, buildArgs(), {
+      stdio: "ignore",
+      detached: true,
+    });
+    child.unref();
+    daemonStateStore.writePid(child.pid);
+    daemonStateStore.writeState({
+      pid: child.pid,
+      startedAt: new Date().toISOString(),
+      port,
+      log,
+      ptyCols,
+      ptyRows,
+      noDefaultSession,
+      noStdin,
+      noStdout,
+      passthrough,
+    });
+    const hostForPrint = resolveHostForPrint();
+    const apiPortForPrint = resolveApiPortForPrint();
+    const isLoopbackHost =
+      hostForPrint === "127.0.0.1" || hostForPrint === "localhost" || hostForPrint === "::1";
+    if (!hasAuthConfigured()) {
+      consoleLike.log(
+        `[${new Date().toISOString()}] WARNING: AUTH_TOKEN not set; API/WS are unauthenticated. Use --auth-token or AUTH_TOKEN env.`
+      );
+      if (!isLoopbackHost) {
+        consoleLike.log(
+          `[${new Date().toISOString()}] WARNING: host=${hostForPrint} is not loopback; unauthenticated API/WS may be exposed.`
+        );
+      }
+    }
+    consoleLike.log(
+      `[${new Date().toISOString()}] Web UI listening on http://${hostForPrint}:${port}`
+    );
+    consoleLike.log(
+      `[${new Date().toISOString()}] API listening on http://${hostForPrint}:${apiPortForPrint}/api`
+    );
+    consoleLike.log(`Started (pid ${child.pid}).`);
+  }
+
+  function stopBackground() {
+    const pid = daemonStateStore.readPid();
+    if (!pid) {
+      consoleLike.log("Not running.");
+      processLike.exit(0);
+      return;
+    }
+    if (!isProcessAlive(pid)) {
+      daemonStateStore.clearPid();
+      consoleLike.log("Not running.");
+      processLike.exit(0);
+      return;
+    }
+    try {
+      processLike.kill(pid, "SIGTERM");
+    } catch {
+      daemonStateStore.clearPid();
+      consoleLike.error("Failed to stop process.");
+      processLike.exit(1);
+      return;
+    }
+    for (let i = 0; i < 20; i += 1) {
+      if (!isProcessAlive(pid)) break;
+      sleepFn(100);
+    }
+    if (isProcessAlive(pid)) {
+      try {
+        processLike.kill(pid, "SIGKILL");
+      } catch {
+        // ignore
+      }
+    }
+    daemonStateStore.clearPid();
+    consoleLike.log("Stopped.");
+  }
+
+  function status() {
+    const pid = daemonStateStore.readPid();
+    if (pid && isProcessAlive(pid)) {
+      const state = daemonStateStore.readState();
+      if (state?.port) {
+        consoleLike.log(`Running (pid ${pid}) on port ${state.port}.`);
+      } else {
+        consoleLike.log(`Running (pid ${pid}).`);
+      }
+      processLike.exit(0);
+      return;
+    }
+    consoleLike.log("Stopped.");
+    processLike.exit(1);
+  }
+
+  function check() {
+    const state = daemonStateStore.readState();
+    const targetPort = state?.port || port;
+    function get(pathname, onDone) {
+      const req = httpLike.get(
+        {
+          host: "127.0.0.1",
+          port: targetPort,
+          path: pathname,
+          timeout: 3000,
+        },
+        (res) => {
+          res.resume();
+          onDone(null, res.statusCode);
+        }
+      );
+      req.on("timeout", () => {
+        req.destroy();
+        onDone(new Error("timeout"));
+      });
+      req.on("error", (err) => {
+        onDone(err);
+      });
+    }
+
+    get("/api/status", (err, statusCode) => {
+      if (err) {
+        consoleLike.error("Unhealthy (connection failed)");
+        processLike.exit(1);
+        return;
+      }
+      if (statusCode >= 200 && statusCode < 300) {
+        consoleLike.log(`OK (http://127.0.0.1:${targetPort}/api/status)`);
+        processLike.exit(0);
+        return;
+      }
+      if (statusCode === 404) {
+        get("/api/sessions", (err2, statusCode2) => {
+          if (err2) {
+            consoleLike.error("Unhealthy (connection failed)");
+            processLike.exit(1);
+            return;
+          }
+          if (statusCode2 >= 200 && statusCode2 < 300) {
+            consoleLike.log(`OK (no default session) http://127.0.0.1:${targetPort}`);
+            processLike.exit(0);
+            return;
+          }
+          consoleLike.error(`Unhealthy (HTTP ${statusCode2})`);
+          processLike.exit(1);
+        });
+        return;
+      }
+      consoleLike.error(`Unhealthy (HTTP ${statusCode})`);
+      processLike.exit(1);
+    });
+  }
+
+  return {
+    runForeground,
+    startBackground,
+    stopBackground,
+    status,
+    check,
+  };
+}
+
+module.exports = {
+  createDaemonService,
+};

package/lib/daemon-state.js

@@ -0,0 +1,55 @@
+function createDaemonStateStore({ fs, homeRoot, pidFile, stateFile }) {
+  function ensureHome() {
+    fs.mkdirSync(homeRoot, { recursive: true });
+  }
+
+  function readState() {
+    try {
+      const raw = fs.readFileSync(stateFile, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+
+  function writeState(state) {
+    ensureHome();
+    fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+  }
+
+  function writePid(pid) {
+    ensureHome();
+    fs.writeFileSync(pidFile, String(pid));
+  }
+
+  function readPid() {
+    try {
+      const raw = fs.readFileSync(pidFile, "utf8");
+      const pid = Number(raw.trim());
+      return Number.isFinite(pid) ? pid : null;
+    } catch {
+      return null;
+    }
+  }
+
+  function clearPid() {
+    try {
+      fs.unlinkSync(pidFile);
+    } catch {
+      // ignore
+    }
+  }
+
+  return {
+    ensureHome,
+    readState,
+    writeState,
+    writePid,
+    readPid,
+    clearPid,
+  };
+}
+
+module.exports = {
+  createDaemonStateStore,
+};

package/lib/format.js

@@ -0,0 +1,29 @@
+const ansiRegex = new RegExp(
+  "[\\u001B\\u009B][[\\]()#;?]*(?:" +
+    "(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?" +
+    "[0-9A-ORZcf-nqry=><~])",
+  "g"
+);
+
+function stripAnsi(text) {
+  return text.replace(ansiRegex, "");
+}
+
+function toMarkdownBlock(text, info = "text") {
+  return `\n\n\`\`\`${info}\n${text}\n\`\`\`\n`;
+}
+
+function formatEventMarkdown(event) {
+  const header = `\n\n### ${event.type}\n\n- ts: ${event.ts}\n`;
+  if (event.content) {
+    return header + toMarkdownBlock(event.content);
+  }
+  return header;
+}
+
+module.exports = {
+  ansiRegex,
+  stripAnsi,
+  toMarkdownBlock,
+  formatEventMarkdown,
+};

package/lib/hooks.js

@@ -0,0 +1,29 @@
+function createHookRegistry(options = {}) {
+  const { onError } = options;
+  const hooks = [];
+
+  function addHook(fn) {
+    hooks.push(fn);
+  }
+
+  function emit(event) {
+    for (const hook of hooks) {
+      try {
+        hook(event);
+      } catch (err) {
+        if (onError) onError(err, event);
+        // isolate hook errors
+      }
+    }
+  }
+
+  return {
+    addHook,
+    emit,
+    hooks,
+  };
+}
+
+module.exports = {
+  createHookRegistry,
+};

package/lib/log-rotate.js

@@ -0,0 +1,109 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+
+function formatTimestamp(date) {
+  const yyyy = date.getFullYear();
+  const mm = pad2(date.getMonth() + 1);
+  const dd = pad2(date.getDate());
+  const hh = pad2(date.getHours());
+  const min = pad2(date.getMinutes());
+  return `${yyyy}${mm}${dd}_${hh}${min}`;
+}
+
+function parseTimestamp(value) {
+  if (!/^\d{8}_\d{4}$/.test(value)) return null;
+  const year = Number(value.slice(0, 4));
+  const month = Number(value.slice(4, 6));
+  const day = Number(value.slice(6, 8));
+  const hour = Number(value.slice(9, 11));
+  const minute = Number(value.slice(11, 13));
+  if (!Number.isFinite(year)) return null;
+  if (!Number.isFinite(month) || month < 1 || month > 12) return null;
+  if (!Number.isFinite(day) || day < 1 || day > 31) return null;
+  if (!Number.isFinite(hour) || hour < 0 || hour > 23) return null;
+  if (!Number.isFinite(minute) || minute < 0 || minute > 59) return null;
+  return new Date(year, month - 1, day, hour, minute, 0, 0).getTime();
+}
+
+function getRotatePattern(filePath) {
+  const filename = path.basename(filePath);
+  if (filename.endsWith(".log")) {
+    return {
+      prefix: filename.slice(0, -4) + ".",
+      suffix: ".log",
+    };
+  }
+  return {
+    prefix: filename + ".",
+    suffix: "",
+  };
+}
+
+function buildRotatedPath(filePath, timestamp) {
+  if (filePath.endsWith(".log")) {
+    return filePath.slice(0, -4) + `.${timestamp}.log`;
+  }
+  return `${filePath}.${timestamp}`;
+}
+
+function cleanupOldRotations(filePath, retainDays, nowTs) {
+  if (!Number.isFinite(retainDays) || retainDays <= 0) return;
+  const dir = path.dirname(filePath);
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch {
+    return;
+  }
+  const { prefix, suffix } = getRotatePattern(filePath);
+  const cutoff = nowTs - retainDays * 24 * 60 * 60 * 1000;
+  for (const entry of entries) {
+    if (!entry.startsWith(prefix) || !entry.endsWith(suffix)) continue;
+    const tsPart = entry.slice(prefix.length, entry.length - suffix.length);
+    const parsed = parseTimestamp(tsPart);
+    if (parsed === null) continue;
+    if (parsed < cutoff) {
+      try {
+        fs.unlinkSync(path.join(dir, entry));
+      } catch {
+        // ignore cleanup errors
+      }
+    }
+  }
+}
+
+function rotateLogFile(filePath, { maxBytes, retainDays, now = new Date() } = {}) {
+  if (!filePath) return;
+  const resolved = path.resolve(filePath);
+  const nowTs = now instanceof Date ? now.getTime() : Date.now();
+  cleanupOldRotations(resolved, retainDays, nowTs);
+
+  let stat;
+  try {
+    stat = fs.statSync(resolved);
+  } catch {
+    return;
+  }
+  if (!stat.isFile()) return;
+  if (Number.isFinite(maxBytes) && stat.size <= maxBytes) return;
+
+  const ts = formatTimestamp(now instanceof Date ? now : new Date(nowTs));
+  const rotatedPath = buildRotatedPath(resolved, ts);
+  try {
+    fs.renameSync(resolved, rotatedPath);
+  } catch {
+    // ignore rotate errors
+  }
+}
+
+module.exports = {
+  rotateLogFile,
+  formatTimestamp,
+  parseTimestamp,
+  buildRotatedPath,
+  cleanupOldRotations,
+};

package/lib/markdown.js

@@ -0,0 +1,40 @@
+const { stripAnsi, toMarkdownBlock } = require("./format");
+
+function sliceText(text, maxChars) {
+  if (!Number.isFinite(maxChars) || maxChars <= 0) return [text];
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    chunks.push(text.slice(start, start + maxChars));
+    start += maxChars;
+  }
+  return chunks;
+}
+
+function formatMarkdownEvent(event, options = {}) {
+  const info = options.info || "text";
+  const maxChars = options.maxChars ?? 0;
+  const clean = options.clean !== false;
+  const content = event.content ?? "";
+  const body = clean ? stripAnsi(content) : content;
+  const chunks = sliceText(body, maxChars);
+
+  const meta = [
+    `- type: ${event.type}`,
+    `- ts: ${event.ts || new Date().toISOString()}`,
+  ];
+  if (event.sessionId) meta.push(`- session: ${event.sessionId}`);
+  if (typeof event.index === "number") meta.push(`- index: ${event.index}`);
+  if (typeof event.total === "number") meta.push(`- total: ${event.total}`);
+
+  return chunks.map((chunk, idx) => {
+    const header = `\n\n### ${event.type}\n\n${meta.join("\n")}\n`;
+    const tag = info + (chunks.length > 1 ? `-${idx + 1}` : "");
+    return header + toMarkdownBlock(chunk, tag);
+  });
+}
+
+module.exports = {
+  sliceText,
+  formatMarkdownEvent,
+};

package/lib/pty.js

@@ -0,0 +1,13 @@
+function normalizeText(text) {
+  return text.replace(/\r?\n/g, "\n");
+}
+
+function makePasteSeq(text) {
+  const normalized = normalizeText(text);
+  return `\u001b[200~${normalized}\u001b[201~`;
+}
+
+module.exports = {
+  normalizeText,
+  makePasteSeq,
+};

package/lib/telegram.js

@@ -0,0 +1,124 @@
+const https = require("node:https");
+let HttpsProxyAgent;
+
+function escapeMarkdownV2(text) {
+  return text.replace(/[_*[\]()~`>#+\-=|{}.!\\]/g, "\\$&");
+}
+
+function escapeMarkdownV2Code(text) {
+  return text.replace(/[\\`]/g, "\\$&");
+}
+
+function sliceText(text, maxChars) {
+  if (!Number.isFinite(maxChars) || maxChars <= 0) return [text];
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    chunks.push(text.slice(start, start + maxChars));
+    start += maxChars;
+  }
+  return chunks;
+}
+
+function formatTelegramMarkdownEvent(event, options = {}) {
+  const maxChars = options.maxChars ?? 3500;
+  const content = event.content ?? "";
+  const chunks = sliceText(content, maxChars);
+  const ts = event.ts || new Date().toISOString();
+  const type = event.type || "event";
+  const sessionId = event.sessionId ? String(event.sessionId) : "";
+
+  return chunks.map((chunk, idx) => {
+    const header = `*${escapeMarkdownV2(type)}*`;
+    const meta = [
+      `- ts: ${escapeMarkdownV2(ts)}`,
+      ...(sessionId ? [`- session: ${escapeMarkdownV2(sessionId)}`] : []),
+      ...(chunks.length > 1
+        ? [`- part: ${escapeMarkdownV2(String(idx + 1))}/${escapeMarkdownV2(String(chunks.length))}`]
+        : []),
+    ];
+    const body = "```\n" + escapeMarkdownV2Code(chunk) + "\n```";
+    return `${header}\n${meta.join("\n")}\n${body}`;
+  });
+}
+
+function getProxyAgent(proxyUrl) {
+  if (!proxyUrl) return undefined;
+  if (!HttpsProxyAgent) {
+    // lazy require to avoid dependency when unused
+    HttpsProxyAgent = require("https-proxy-agent");
+  }
+  return new HttpsProxyAgent(proxyUrl);
+}
+
+async function sendTelegramMessage({
+  token,
+  chatId,
+  text,
+  parseMode = "MarkdownV2",
+  proxy,
+  timeoutMs = 10000,
+}) {
+  const payload = JSON.stringify({
+    chat_id: chatId,
+    text,
+    parse_mode: parseMode,
+    disable_web_page_preview: true,
+  });
+
+  const options = {
+    method: "POST",
+    hostname: "api.telegram.org",
+    path: `/bot${token}/sendMessage`,
+    headers: {
+      "Content-Type": "application/json",
+      "Content-Length": Buffer.byteLength(payload),
+    },
+    timeout: timeoutMs,
+    agent: getProxyAgent(proxy),
+  };
+
+  return new Promise((resolve, reject) => {
+    const req = https.request(options, (res) => {
+      let data = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+      res.on("end", () => {
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+          resolve({ ok: true, status: res.statusCode });
+          return;
+        }
+        reject(new Error(`telegram status ${res.statusCode}: ${data}`));
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy(new Error("telegram timeout"));
+    });
+    req.write(payload);
+    req.end();
+  });
+}
+
+async function sendWithRetry(options, retry = 2, backoffMs = 1000, sendFn = sendTelegramMessage) {
+  let attempt = 0;
+  while (true) {
+    try {
+      return await sendFn(options);
+    } catch (err) {
+      attempt += 1;
+      if (attempt > retry) throw err;
+      await new Promise((resolve) => setTimeout(resolve, backoffMs * attempt));
+    }
+  }
+}
+
+module.exports = {
+  escapeMarkdownV2,
+  escapeMarkdownV2Code,
+  formatTelegramMarkdownEvent,
+  sendTelegramMessage,
+  sendWithRetry,
+};