copilot-proxy-web 1.0.0

package/lib/cloudflare-setup-deps.js

@@ -0,0 +1,136 @@
+function createCloudflareSetupDeps({
+  fs,
+  path,
+  os,
+  dns,
+  spawnSync,
+  cfRoot,
+  cfConfigFile,
+}) {
+  function readLatestCredentialsFile() {
+    const dir = path.join(os.homedir(), ".cloudflared");
+    let entries;
+    try {
+      entries = fs.readdirSync(dir);
+    } catch {
+      return null;
+    }
+    let latest = null;
+    let latestMtime = 0;
+    for (const entry of entries) {
+      if (!entry.endsWith(".json")) continue;
+      const full = path.join(dir, entry);
+      let stat;
+      try {
+        stat = fs.statSync(full);
+      } catch {
+        continue;
+      }
+      if (!stat.isFile()) continue;
+      if (stat.mtimeMs > latestMtime) {
+        latestMtime = stat.mtimeMs;
+        latest = full;
+      }
+    }
+    return latest;
+  }
+
+  async function lookupDnsAddresses(hostname) {
+    if (!hostname) return { status: "missing" };
+    try {
+      const [v4, v6] = await Promise.allSettled([
+        dns.promises.resolve4(hostname),
+        dns.promises.resolve6(hostname),
+      ]);
+      const addrs = [];
+      if (v4.status === "fulfilled") addrs.push(...(v4.value || []));
+      if (v6.status === "fulfilled") addrs.push(...(v6.value || []));
+      if (addrs.length === 0) return { status: "missing" };
+      return { status: "found", addrs };
+    } catch (err) {
+      return { status: "error", error: err };
+    }
+  }
+
+  function hasOriginCert() {
+    try {
+      fs.accessSync(path.join(os.homedir(), ".cloudflared", "cert.pem"), fs.constants.R_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  function resolveTunnelId(bin, name) {
+    const res = spawnSync(bin, ["tunnel", "list"], { encoding: "utf8" });
+    if (res.error) return null;
+    const lines = (res.stdout || "").split("\n").slice(1);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const parts = trimmed.split(/\s+/);
+      if (parts.length >= 2) {
+        const [id, tunnelName] = parts;
+        if (tunnelName === name) return id;
+      }
+    }
+    return null;
+  }
+
+  function findDnsRouteLine(bin, hostname) {
+    const res = spawnSync(bin, ["tunnel", "route", "dns", "list"], { encoding: "utf8" });
+    if (res.error || res.status !== 0) return null;
+    const needle = hostname.toLowerCase();
+    const line = (res.stdout || "")
+      .split("\n")
+      .find((line) => line.toLowerCase().includes(needle));
+    return line || null;
+  }
+
+  function findCredentialsForTunnel(tunnelId) {
+    if (!tunnelId) return null;
+    const file = path.join(os.homedir(), ".cloudflared", `${tunnelId}.json`);
+    try {
+      fs.accessSync(file, fs.constants.R_OK);
+      return file;
+    } catch {
+      return null;
+    }
+  }
+
+  function writeCloudflareConfigWithService({
+    tunnel,
+    credentialsFile,
+    hostname,
+    service,
+    pathMatch,
+  }) {
+    fs.mkdirSync(cfRoot, { recursive: true });
+    const pathLine = pathMatch ? `    path: ${pathMatch}` : null;
+    const content = [
+      `tunnel: ${tunnel}`,
+      `credentials-file: ${credentialsFile}`,
+      "ingress:",
+      `  - hostname: ${hostname}`,
+      ...(pathLine ? [pathLine] : []),
+      `    service: ${service}`,
+      "  - service: http_status:404",
+      "",
+    ].join("\n");
+    fs.writeFileSync(cfConfigFile, content);
+  }
+
+  return {
+    readLatestCredentialsFile,
+    lookupDnsAddresses,
+    hasOriginCert,
+    resolveTunnelId,
+    findDnsRouteLine,
+    findCredentialsForTunnel,
+    writeCloudflareConfigWithService,
+  };
+}
+
+module.exports = {
+  createCloudflareSetupDeps,
+};

package/lib/cloudflare-setup-service.js

@@ -0,0 +1,277 @@
+function createCloudflareSetupService({
+  extractHostname,
+  inferDomainFromHostname,
+  resolveHostnameWithDomain,
+  ensureCloudflaredOrExit,
+  port,
+  cfStateStore,
+  resolveTunnelId,
+  findCredentialsForTunnel,
+  readLatestCredentialsFile,
+  hasOriginCert,
+  lookupDnsAddresses,
+  findDnsRouteLine,
+  writeCloudflareConfigWithService,
+  parseRouteCreatedRecord,
+  spawnFn,
+  consoleLike,
+  processLike,
+  formatCheckLine,
+  cfConfigFile,
+}) {
+  function cloudflareSetup(cfArgs) {
+    function getArg(flag) {
+      const idx = cfArgs.indexOf(flag);
+      if (idx >= 0 && idx + 1 < cfArgs.length) return cfArgs[idx + 1];
+      return null;
+    }
+    const tunnelName = getArg("--tunnel-name") || "copilot-proxy-web";
+    const rawHostname = extractHostname(getArg("--hostname"));
+    let domain = extractHostname(getArg("--domain"));
+    let inferredDomain = "";
+    if (!domain && rawHostname) {
+      inferredDomain = inferDomainFromHostname(rawHostname);
+      if (inferredDomain) domain = inferredDomain;
+    }
+    let hostname = rawHostname;
+    let inferredHostname = false;
+    try {
+      const resolved = resolveHostnameWithDomain(rawHostname, domain);
+      hostname = resolved.hostname;
+      inferredHostname = Boolean(rawHostname) && Boolean(domain) && !rawHostname.includes(".");
+    } catch (err) {
+      consoleLike.error(err?.message || "Invalid --domain/--hostname combination");
+      processLike.exit(1);
+      return;
+    }
+    const localPort = getArg("--port") || port;
+    const serviceMode = getArg("--service");
+    const serviceUrl = getArg("--service-url");
+    const pathMatch = getArg("--path");
+    let serviceTarget = `http://127.0.0.1:${localPort}`;
+    let inferredService = true;
+    if (serviceUrl) {
+      serviceTarget = serviceUrl.trim();
+      inferredService = false;
+    } else if (serviceMode) {
+      const mode = serviceMode.trim().toLowerCase();
+      if (mode !== "http" && mode !== "https") {
+        consoleLike.error("Invalid --service. Use http or https.");
+        processLike.exit(1);
+        return;
+      }
+      serviceTarget = `${mode}://127.0.0.1:${localPort}`;
+      inferredService = false;
+    }
+    if (!hostname) {
+      consoleLike.error("Missing --hostname (e.g. --hostname proxy.example.com)");
+      consoleLike.error("Examples:");
+      consoleLike.error("  npx copilot-proxy-web cloudflare setup --hostname proxy.example.com");
+      consoleLike.error("  npx copilot-proxy-web cloudflare setup --hostname proxy.example.com --tunnel-name copilot-proxy-web");
+      consoleLike.error("  npx copilot-proxy-web cloudflare setup --hostname proxy.example.com --tunnel-name copilot-proxy-web --port 3000");
+      consoleLike.error("  npx copilot-proxy-web cloudflare setup --hostname proxy.example.com --tunnel-name copilot-proxy-web --port 3000 --service http");
+      consoleLike.error("  npx copilot-proxy-web cloudflare setup --hostname proxy.example.com --tunnel-name copilot-proxy-web --service http --service-url http://127.0.0.1:3000");
+      consoleLike.error("  npx copilot-proxy-web cloudflare setup --hostname proxy.example.com --tunnel-name copilot-proxy-web --service https --service-url https://127.0.0.1:3000");
+      consoleLike.error("This will create a Cloudflare Tunnel and route DNS for that hostname.");
+      consoleLike.error(`Service target: http://127.0.0.1:${port} (HTTP only by default)`);
+      consoleLike.error("You can override service with --service http|https or --service-url <url>.");
+      consoleLike.error("Use --path <path> to match a public URL path (requires --service-url if you need a different target path).");
+      consoleLike.error("Use --domain <zone> to pin a DNS zone or allow short hostnames (auto-infers from hostname if omitted).");
+      consoleLike.error("Auth options:");
+      consoleLike.error("  1) cloudflared tunnel login (creates ~/.cloudflared/cert.pem for management)");
+      consoleLike.error("  2) tunnel credentials JSON (~/.cloudflared/<TUNNEL-UUID>.json for locally-managed tunnel)");
+      consoleLike.error("  3) tunnel token (Zero Trust Dashboard → Networks → Connectors → (tunnel) → token)");
+      consoleLike.error("Docs: https://developers.cloudflare.com/cloudflare-one/");
+      processLike.exit(1);
+      return;
+    }
+    if (!domain && !hostname.includes(".")) {
+      consoleLike.error("Missing --domain for short hostname (e.g. --hostname office --domain example.com)");
+      processLike.exit(1);
+      return;
+    }
+    if (domain && !(hostname.toLowerCase() === domain.toLowerCase() || hostname.toLowerCase().endsWith(`.${domain.toLowerCase()}`))) {
+      consoleLike.error(`Hostname '${hostname}' is outside --domain '${domain}'.`);
+      processLike.exit(1);
+      return;
+    }
+    const bin = ensureCloudflaredOrExit();
+    consoleLike.log("Cloudflare setup:");
+    consoleLike.log(`  hostname: ${hostname}${inferredHostname ? " (inferred)" : ""}`);
+    if (domain) consoleLike.log(`  domain: ${domain}${inferredDomain ? " (inferred)" : ""}`);
+    consoleLike.log(`  tunnel-name: ${tunnelName}`);
+    consoleLike.log(`  port: ${localPort}`);
+    consoleLike.log(`  service: ${serviceTarget}${inferredService ? " (default)" : ""}`);
+    if (pathMatch) consoleLike.log(`  path: ${pathMatch}`);
+
+    const hasCert = hasOriginCert();
+    const preflightTunnelId = hasCert ? resolveTunnelId(bin, tunnelName) : null;
+    const preflightToken = cfStateStore.hasToken();
+    const preflightCredentials =
+      (preflightTunnelId && findCredentialsForTunnel(preflightTunnelId)) ||
+      (hasCert ? readLatestCredentialsFile() : null);
+
+    const runLogin = () =>
+      new Promise((resolve, reject) => {
+        const proc = spawnFn(bin, ["tunnel", "login"], { stdio: "inherit" });
+        proc.on("exit", (code) => {
+          if (code === 0) resolve();
+          else reject(new Error("login failed"));
+        });
+      });
+
+    const runCreate = () =>
+      new Promise((resolve, reject) => {
+        const proc = spawnFn(bin, ["tunnel", "create", tunnelName], { stdio: "inherit" });
+        proc.on("exit", (code) => {
+          if (code === 0) resolve();
+          else reject(new Error("create failed"));
+        });
+      });
+
+    const runRoute = () =>
+      new Promise((resolve, reject) => {
+        const proc = spawnFn(bin, ["tunnel", "route", "dns", tunnelName, hostname], {
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stderr = "";
+        proc.stdout.on("data", (chunk) => {
+          processLike.stdout.write(String(chunk));
+        });
+        proc.stderr.on("data", (chunk) => {
+          const text = String(chunk);
+          stderr += text;
+          processLike.stderr.write(text);
+        });
+        proc.on("exit", (code) => {
+          if (code === 0) {
+            resolve();
+            return;
+          }
+          if (/code:\s*1003/i.test(stderr) || /already exists/i.test(stderr)) {
+            consoleLike.error("Hint: overwrite the existing record with:");
+            consoleLike.error(`  cloudflared tunnel route dns -f ${tunnelName} ${hostname}`);
+          }
+          const createdRecord = parseRouteCreatedRecord(stderr);
+          if (createdRecord && domain) {
+            const lowerDomain = domain.toLowerCase();
+            const lowerCreated = createdRecord.toLowerCase();
+            if (!(lowerCreated === lowerDomain || lowerCreated.endsWith(`.${lowerDomain}`))) {
+              reject(
+                new Error(
+                  `route failed: cloudflared is targeting a different zone (${createdRecord}). Re-run 'cloudflared tunnel login' and choose zone '${domain}'.`
+                )
+              );
+              return;
+            }
+          }
+          reject(new Error("route failed"));
+        });
+      });
+
+    (async () => {
+      const dnsLookup = await lookupDnsAddresses(hostname);
+      consoleLike.log("Preflight checks:");
+      consoleLike.log("  [1] Hostname / Application");
+      consoleLike.log(formatCheckLine("    hostname", hostname));
+      consoleLike.log(formatCheckLine("    domain", domain || "missing"));
+      consoleLike.log(formatCheckLine("    zero trust app", "needs manual check in Zero Trust dashboard"));
+      consoleLike.log("  [2] Tunnel");
+      consoleLike.log(formatCheckLine("    tunnel-name", tunnelName));
+      consoleLike.log(
+        formatCheckLine(
+          "    tunnel",
+          preflightTunnelId ? `exists (${preflightTunnelId})` : hasCert ? "missing" : "unknown (login required)"
+        )
+      );
+      consoleLike.log("  [3] Tunnel ↔ DNS Route");
+      if (dnsLookup.status === "found") {
+        consoleLike.log(formatCheckLine("    dns lookup", "found (record exists; proxy may hide CNAME)"));
+      } else if (dnsLookup.status === "missing") {
+        consoleLike.log(formatCheckLine("    dns lookup", "missing"));
+      } else {
+        consoleLike.log(formatCheckLine("    dns lookup", "unknown (lookup failed)"));
+      }
+      consoleLike.log(formatCheckLine("    dns route", "needs manual check (cloudflared or Zero Trust dashboard)"));
+      consoleLike.log(formatCheckLine("    hint", `cloudflared tunnel route dns ${tunnelName} ${hostname}`));
+      consoleLike.log(formatCheckLine("    hint", `nslookup ${hostname}`));
+      consoleLike.log("  [4] Local credentials");
+      consoleLike.log(formatCheckLine("    login", hasCert ? "OK" : "required"));
+      if (preflightCredentials) {
+        consoleLike.log(formatCheckLine("    credentials", preflightCredentials));
+      } else {
+        consoleLike.log(formatCheckLine("    credentials", "missing (download JSON or use token)"));
+      }
+      consoleLike.log(formatCheckLine("    token", preflightToken ? "present" : "missing"));
+      if (hasCert && preflightTunnelId && !preflightCredentials && !preflightToken) {
+        consoleLike.log("Next steps:");
+        consoleLike.log("  - Download tunnel credentials JSON from Zero Trust → Networks → Connectors → (tunnel) and place it in ~/.cloudflared/");
+        consoleLike.log("  - Or set a tunnel token and skip credentials: npx copilot-proxy-web cloudflare token set --token <TOKEN>");
+      }
+      if (!hasCert) {
+        await runLogin();
+      }
+      const tunnelId = resolveTunnelId(bin, tunnelName);
+      const existingRouteLine = findDnsRouteLine(bin, hostname);
+      if (existingRouteLine) {
+        if (tunnelId && existingRouteLine.includes(tunnelId)) {
+          consoleLike.log(`Cloudflare DNS route already exists for ${hostname}.`);
+        } else {
+          consoleLike.error(`Hostname already has a DNS route: ${hostname}`);
+          consoleLike.error(existingRouteLine.trim());
+          consoleLike.error("Please remove or update the DNS route manually, then retry.");
+          processLike.exit(1);
+          return;
+        }
+      }
+      if (!tunnelId) {
+        await runCreate();
+      }
+      const resolvedId = resolveTunnelId(bin, tunnelName);
+      const credentialsFile =
+        findCredentialsForTunnel(resolvedId) || readLatestCredentialsFile();
+      if (!credentialsFile) {
+        consoleLike.error("Failed to locate credentials file in ~/.cloudflared");
+        consoleLike.error("Download credentials from Zero Trust dashboard and place it there.");
+        processLike.exit(1);
+        return;
+      }
+      writeCloudflareConfigWithService({
+        tunnel: resolvedId || tunnelName,
+        credentialsFile,
+        hostname,
+        service: serviceTarget,
+        pathMatch: pathMatch || null,
+      });
+      if (!existingRouteLine) {
+        const routeTarget = resolvedId ? `${tunnelName} (${resolvedId})` : tunnelName;
+        consoleLike.log(`Routing DNS: ${hostname} -> ${routeTarget}`);
+        await runRoute();
+      }
+      cfStateStore.writeCfState({
+        tunnelName,
+        tunnelId: resolvedId || tunnelName,
+        hostname,
+        domain: domain || null,
+        localPort,
+        path: pathMatch || null,
+        service: serviceTarget,
+        credentialsFile,
+        configFile: cfConfigFile,
+        createdAt: new Date().toISOString(),
+      });
+      consoleLike.log("Cloudflare tunnel setup complete.");
+    })().catch((err) => {
+      consoleLike.error(err?.message || "cloudflare setup failed");
+      processLike.exit(1);
+    });
+  }
+
+  return {
+    cloudflareSetup,
+  };
+}
+
+module.exports = {
+  createCloudflareSetupService,
+};

package/lib/cloudflare-state.js

@@ -0,0 +1,100 @@
+function createCloudflareStateStore({ fs, paths }) {
+  function readCfState() {
+    try {
+      const raw = fs.readFileSync(paths.cfStateFile, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+
+  function writeCfState(state) {
+    fs.mkdirSync(paths.cfRoot, { recursive: true });
+    fs.writeFileSync(paths.cfStateFile, JSON.stringify(state, null, 2));
+  }
+
+  function writeCfPid(pid) {
+    fs.mkdirSync(paths.cfRoot, { recursive: true });
+    fs.writeFileSync(paths.cfPidFile, String(pid));
+  }
+
+  function readCfPid() {
+    try {
+      const raw = fs.readFileSync(paths.cfPidFile, "utf8");
+      const pid = Number(raw.trim());
+      return Number.isFinite(pid) ? pid : null;
+    } catch {
+      return null;
+    }
+  }
+
+  function clearCfPid() {
+    try {
+      fs.unlinkSync(paths.cfPidFile);
+    } catch {
+      // ignore
+    }
+  }
+
+  function readToken() {
+    try {
+      return fs.readFileSync(paths.cfTokenFile, "utf8").trim();
+    } catch {
+      return "";
+    }
+  }
+
+  function hasToken() {
+    try {
+      fs.accessSync(paths.cfTokenFile, fs.constants.R_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  function setToken(tokenValue) {
+    fs.mkdirSync(paths.cfRoot, { recursive: true });
+    fs.writeFileSync(paths.cfTokenFile, tokenValue, { mode: 0o600 });
+  }
+
+  function clearToken() {
+    try {
+      if (fs.existsSync(paths.cfTokenFile)) fs.unlinkSync(paths.cfTokenFile);
+    } catch {
+      // ignore
+    }
+  }
+
+  function patchCfState(patch) {
+    const current = readCfState() || {};
+    const next = { ...current, ...patch };
+    writeCfState(next);
+    return next;
+  }
+
+  function clean() {
+    if (fs.existsSync(paths.cfConfigFile)) fs.unlinkSync(paths.cfConfigFile);
+    if (fs.existsSync(paths.cfStateFile)) fs.unlinkSync(paths.cfStateFile);
+    if (fs.existsSync(paths.cfPidFile)) fs.unlinkSync(paths.cfPidFile);
+  }
+
+  return {
+    paths,
+    readCfState,
+    writeCfState,
+    writeCfPid,
+    readCfPid,
+    clearCfPid,
+    readToken,
+    hasToken,
+    setToken,
+    clearToken,
+    patchCfState,
+    clean,
+  };
+}
+
+module.exports = {
+  createCloudflareStateStore,
+};

package/lib/cloudflare-utils.js

@@ -0,0 +1,69 @@
+function normalizePath(value) {
+  if (!value) return "/";
+  const trimmed = value.trim();
+  if (!trimmed) return "/";
+  if (trimmed.startsWith("/")) return trimmed;
+  return `/${trimmed}`;
+}
+
+function extractHostname(value) {
+  if (!value) return "";
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  if (trimmed.includes("://")) {
+    try {
+      const url = new URL(trimmed);
+      return url.hostname;
+    } catch {
+      return trimmed.replace(/^\s+|\s+$/g, "");
+    }
+  }
+  return trimmed.replace(/^\s+|\s+$/g, "").replace(/\/+$/, "");
+}
+
+function resolveHostnameWithDomain(rawHostname, domain) {
+  const hostname = extractHostname(rawHostname);
+  const zone = extractHostname(domain);
+  if (!zone) return { hostname, zone: "" };
+  const lowerHost = hostname.toLowerCase();
+  const lowerZone = zone.toLowerCase();
+  if (!hostname) return { hostname: "", zone: lowerZone };
+  if (lowerHost === lowerZone || lowerHost.endsWith(`.${lowerZone}`)) {
+    return { hostname, zone: lowerZone };
+  }
+  if (hostname.includes(".")) {
+    throw new Error(`Hostname '${hostname}' is outside --domain '${zone}'.`);
+  }
+  return { hostname: `${hostname}.${zone}`, zone: lowerZone };
+}
+
+function inferDomainFromHostname(rawHostname) {
+  const hostname = extractHostname(rawHostname);
+  if (!hostname) return "";
+  if (hostname.includes(":")) return "";
+  if (/^\d{1,3}(\.\d{1,3}){3}$/.test(hostname)) return "";
+  const parts = hostname.split(".").filter(Boolean);
+  if (parts.length < 2) return "";
+  return parts.slice(-2).join(".");
+}
+
+function formatCheckLine(label, value) {
+  const text = value ? String(value) : "missing";
+  return `  ${label}: ${text}`;
+}
+
+function parseRouteCreatedRecord(stderrText) {
+  if (!stderrText) return null;
+  const match = stderrText.match(/Failed to create record\s+([^\s]+)\s+with err/i);
+  if (!match) return null;
+  return extractHostname(match[1]);
+}
+
+module.exports = {
+  normalizePath,
+  extractHostname,
+  resolveHostnameWithDomain,
+  inferDomainFromHostname,
+  formatCheckLine,
+  parseRouteCreatedRecord,
+};

package/lib/conversation-profiles.js

@@ -0,0 +1,80 @@
+function detectProfileFromChunk(chunk = "", state = null) {
+  const text = String(chunk);
+  const hasCopilotVersion = /GitHub Copilot v/i.test(text);
+  const hasPromptMarker = text.includes("Type @ to mention files");
+
+  if (state && typeof state === "object") {
+    if (hasCopilotVersion) state.seenVersion = true;
+    if (hasPromptMarker) state.seenPrompt = true;
+    if (state.seenVersion && state.seenPrompt) return "copilot";
+    return "";
+  }
+
+  if (hasCopilotVersion && hasPromptMarker) {
+    return "copilot";
+  }
+  return "";
+}
+
+function filterConversationLines(lines, profile = "none") {
+  if (profile !== "copilot") return lines;
+
+  const isSeparatorLine = (value) => /^[─━\-]+$/.test(value.replace(/\s+/g, ""));
+  const isThinkingLine = (value) =>
+    /^[◐◑◒◓◎◉∙•●]\s+Thinking \(Esc to cancel/.test(value.trim());
+  const isPromptOrFooterLine = (value) => {
+    const t = value.trim();
+    if (!t) return true;
+    if (isSeparatorLine(t)) return true;
+    if (t.startsWith("❯")) return true;
+    if (t.includes("Type @ to mention files")) return true;
+    if (t.includes("shift+tab cycle mode")) return true;
+    if (t.includes("Remaining requests")) return true;
+    if (/^[/~].*\[[^\]]+\]/.test(t)) return true;
+    return false;
+  };
+  const stripPromptBlockFromBottom = (inputLines) => {
+    if (!Array.isArray(inputLines) || inputLines.length < 4) return inputLines;
+    const out = inputLines.slice();
+    let n = -1;
+    for (let i = out.length - 1; i >= 0; i -= 1) {
+      const t = String(out[i] || "").trim();
+      if (t.includes("shift+tab cycle mode")) {
+        n = i;
+        break;
+      }
+    }
+    if (n < 2) return out;
+    const sepBelowPrompt = String(out[n - 1] || "").trim();
+    const promptLine = String(out[n - 2] || "").trim();
+    if (!isSeparatorLine(sepBelowPrompt)) return out;
+    if (!(promptLine.startsWith("❯") || promptLine.includes("Type @ to mention files"))) return out;
+    let m = -1;
+    for (let i = n - 3; i >= 0; i -= 1) {
+      if (isSeparatorLine(String(out[i] || "").trim())) {
+        m = i;
+        break;
+      }
+    }
+    if (m < 0 || m >= n - 1) return out;
+    out.splice(m, (n - 1) - m + 1);
+    return out;
+  };
+
+  const out = stripPromptBlockFromBottom(lines);
+  const trimmed = out.map((line) => String(line || "").trim()).filter(Boolean);
+  if (!trimmed.length) return out;
+  const thinking = trimmed.filter((line) => isThinkingLine(line));
+  const informative = trimmed.filter(
+    (line) => !isThinkingLine(line) && !isPromptOrFooterLine(line)
+  );
+  if (thinking.length && informative.length === 0) {
+    return [thinking[thinking.length - 1]];
+  }
+  return out;
+}
+
+module.exports = {
+  detectProfileFromChunk,
+  filterConversationLines,
+};