context-lens 0.3.2 → 0.4.0

package/dist/cli.js

@@ -1,69 +1,103 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import fs from "node:fs";
+import https from "node:https";
 import net from "node:net";
-import { platform, tmpdir } from "node:os";
+import { homedir, platform, tmpdir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { CLI_CONSTANTS, getToolConfig } from "./cli-utils.js";
+import { CLI_CONSTANTS, formatHelpText, getToolConfig, parseCliArgs, } from "./cli-utils.js";
+import { VERSION } from "./version.generated.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Known tool config: env vars for the child process, extra CLI args, server env vars, and whether mitmproxy is needed
 // Note: actual tool config lives in cli-utils.ts so it can be unit-tested without importing this entrypoint.
 const LOCKFILE = "/tmp/context-lens.lock";
-// Parse command line arguments
-const args = process.argv.slice(2);
-// Extract --privacy flag from args (before or after command)
-let privacyLevel;
-const filteredArgs = [];
-for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--privacy" && i + 1 < args.length) {
-        privacyLevel = args[i + 1];
-        i++; // skip the value
-    }
-    else if (args[i].startsWith("--privacy=")) {
-        privacyLevel = args[i].split("=", 2)[1];
-    }
-    else {
-        filteredArgs.push(args[i]);
-    }
+const parsedArgs = parseCliArgs(process.argv.slice(2));
+if (parsedArgs.error) {
+    console.error(parsedArgs.error);
+    process.exit(1);
 }
-// Validate privacy level
-if (privacyLevel !== undefined) {
-    if (!["minimal", "standard", "full"].includes(privacyLevel)) {
-        console.error(`Error: Invalid privacy level '${privacyLevel}'. Must be one of: minimal, standard, full`);
-        process.exit(1);
-    }
-    // Pass to server via env var
-    process.env.CONTEXT_LENS_PRIVACY = privacyLevel;
+if (parsedArgs.showHelp) {
+    console.log(formatHelpText());
+    process.exit(0);
 }
-if (filteredArgs.length === 0) {
-    // Standalone mode: just start the proxy server
-    const serverPath = join(__dirname, "server.js");
-    const server = spawn("node", [serverPath], {
-        stdio: "inherit",
-        env: { ...process.env },
-    });
-    server.on("exit", (code) => process.exit(code || 0));
-    process.on("SIGINT", () => server.kill("SIGINT"));
-    process.on("SIGTERM", () => server.kill("SIGTERM"));
-    // Prevent early exit
-    process.stdin.resume();
+if (parsedArgs.showVersion) {
+    console.log(VERSION);
+    process.exit(0);
 }
-else {
-    // Skip '--' separator if present
-    let commandArgs = filteredArgs;
-    if (filteredArgs[0] === "--") {
-        commandArgs = filteredArgs.slice(1);
+if (parsedArgs.privacyLevel !== undefined) {
+    process.env.CONTEXT_LENS_PRIVACY = parsedArgs.privacyLevel;
+}
+if (!parsedArgs.noUpdateCheck &&
+    process.env.CONTEXT_LENS_NO_UPDATE_CHECK !== "1") {
+    void checkForUpdate(VERSION);
+}
+if (parsedArgs.commandName === "analyze") {
+    void runAnalyze(parsedArgs.commandArguments).then((exitCode) => process.exit(exitCode));
+}
+else if (parsedArgs.commandName === "doctor") {
+    void runDoctor().then((exitCode) => process.exit(exitCode));
+}
+else if (parsedArgs.commandName === "background") {
+    void runBackgroundCommand(parsedArgs.commandArguments, parsedArgs.noUi).then((exitCode) => process.exit(exitCode));
+}
+else if (!parsedArgs.commandName) {
+    if (parsedArgs.noUi) {
+        // Standalone mode (no UI): start proxy only
+        const proxyPath = join(__dirname, "proxy", "server.js");
+        const proxy = spawn("node", [proxyPath], {
+            stdio: "inherit",
+            env: { ...process.env },
+        });
+        function shutdownStandaloneProxyOnly(code) {
+            if (!proxy.killed)
+                proxy.kill();
+            process.exit(code);
+        }
+        proxy.on("exit", (code) => shutdownStandaloneProxyOnly(code || 0));
+        process.on("SIGINT", () => shutdownStandaloneProxyOnly(0));
+        process.on("SIGTERM", () => shutdownStandaloneProxyOnly(0));
+        process.stdin.resume();
     }
-    if (commandArgs.length === 0) {
-        console.error("Error: No command specified after --");
-        process.exit(1);
+    else {
+        // Standalone mode: start both proxy and analysis server
+        const proxyPath = join(__dirname, "proxy", "server.js");
+        const analysisPath = join(__dirname, "analysis", "server.js");
+        const proxy = spawn("node", [proxyPath], {
+            stdio: "inherit",
+            env: { ...process.env },
+        });
+        const analysis = spawn("node", [analysisPath], {
+            stdio: "inherit",
+            env: { ...process.env },
+        });
+        function shutdownStandalone(code) {
+            if (!proxy.killed)
+                proxy.kill();
+            if (!analysis.killed)
+                analysis.kill();
+            process.exit(code);
+        }
+        proxy.on("exit", (code) => shutdownStandalone(code || 0));
+        analysis.on("exit", (code) => shutdownStandalone(code || 0));
+        process.on("SIGINT", () => shutdownStandalone(0));
+        process.on("SIGTERM", () => shutdownStandalone(0));
+        // Prevent early exit
+        process.stdin.resume();
     }
-    const commandName = commandArgs[0];
-    const commandArguments = commandArgs.slice(1);
+}
+else {
+    const commandName = parsedArgs.commandName;
+    const commandArguments = parsedArgs.commandArguments;
+    const noOpen = parsedArgs.noOpen;
+    const noUi = parsedArgs.noUi;
     // Get tool-specific config
     const toolConfig = getToolConfig(commandName);
+    if (noUi && toolConfig.needsMitm) {
+        console.error("Error: --no-ui is not supported for this command because mitm capture requires the analysis ingest API on :4041.");
+        process.exit(1);
+    }
     // Check if proxy is already running
     function isProxyRunning() {
         return new Promise((resolve) => {
@@ -124,71 +158,151 @@ else {
             return 0;
         }
     }
-    let serverProcess = null;
+    let proxyProcess = null;
+    let analysisProcess = null;
     let mitmProcess = null;
-    let serverReady = false;
+    let proxyReady = false;
+    let analysisReady = false;
     let mitmReady = false;
     let childProcess = null;
     let piAgentDirToCleanup = null;
-    let shouldShutdownProxy = false;
+    let shouldShutdownServers = false;
     let cleanupDidRun = false;
-    // Start proxy or attach to existing one
-    async function initializeProxy() {
-        const alreadyRunning = await isProxyRunning();
-        if (alreadyRunning) {
-            console.log("🔍 Context Lens proxy already running, attaching to it...");
-            incrementRefCount();
-            serverReady = true;
-            shouldShutdownProxy = false;
+    const requiresAnalysis = !noUi;
+    function checkBothReady() {
+        if (proxyReady && analysisReady) {
             maybeStartMitmThenChild();
         }
-        else {
-            console.log("🔍 Starting Context Lens proxy and web UI...");
-            // No proxy is listening on :4040. Any existing lockfile is stale and would prevent shutdown later.
-            clearStaleLockfile();
+    }
+    // Check if analysis server is already running
+    function isAnalysisRunning() {
+        return new Promise((resolve) => {
+            const socket = net.connect({ port: 4041, host: "localhost" }, () => {
+                socket.end();
+                resolve(true);
+            });
+            socket.on("error", () => resolve(false));
+            socket.setTimeout(1000, () => {
+                socket.destroy();
+                resolve(false);
+            });
+        });
+    }
+    // Start proxy and analysis server (or attach to existing ones)
+    async function initializeServers() {
+        const proxyAlreadyRunning = await isProxyRunning();
+        const analysisAlreadyRunning = requiresAnalysis
+            ? await isAnalysisRunning()
+            : false;
+        const allRequiredRunning = proxyAlreadyRunning && (!requiresAnalysis || analysisAlreadyRunning);
+        if (allRequiredRunning) {
+            console.log("🔍 Context Lens already running, attaching...");
             incrementRefCount();
-            shouldShutdownProxy = true;
-            const serverPath = join(__dirname, "server.js");
-            serverProcess = spawn("node", [serverPath], {
+            proxyReady = true;
+            analysisReady = !requiresAnalysis || analysisAlreadyRunning;
+            shouldShutdownServers = false;
+            checkBothReady();
+            return;
+        }
+        console.log("🔍 Starting Context Lens proxy and analysis server...");
+        // Clear stale lockfile if servers aren't actually running
+        if (!proxyAlreadyRunning)
+            clearStaleLockfile();
+        incrementRefCount();
+        shouldShutdownServers = true;
+        const serverEnv = {
+            ...toolConfig.serverEnv,
+            ...process.env,
+            CONTEXT_LENS_CLI: "1",
+        };
+        // Start proxy
+        if (proxyAlreadyRunning) {
+            proxyReady = true;
+        }
+        else {
+            const proxyPath = join(__dirname, "proxy", "server.js");
+            proxyProcess = spawn("node", [proxyPath], {
                 stdio: ["ignore", "pipe", "pipe"],
                 detached: false,
-                env: { ...toolConfig.serverEnv, ...process.env, CONTEXT_LENS_CLI: "1" },
+                env: serverEnv,
             });
-            // Wait for server to be ready, then suppress output (visible in web UI at :4041)
-            serverProcess.stdout?.on("data", (data) => {
+            proxyProcess.stdout?.on("data", (data) => {
                 const output = data.toString();
-                if (!serverReady) {
+                if (!proxyReady)
                     process.stderr.write(output);
-                }
-                if (output.includes("Context Lens Web UI running") && !serverReady) {
-                    serverReady = true;
-                    maybeStartMitmThenChild();
+                if (output.includes("Context Lens Proxy running") && !proxyReady) {
+                    proxyReady = true;
+                    checkBothReady();
                 }
             });
-            serverProcess.stderr?.on("data", (data) => {
-                if (!serverReady) {
+            proxyProcess.stderr?.on("data", (data) => {
+                if (!proxyReady)
                     process.stderr.write(data);
+            });
+            proxyProcess.on("error", (err) => {
+                console.error("Failed to start proxy:", err);
+                decrementRefCount();
+                process.exit(1);
+            });
+            proxyProcess.on("exit", (code) => {
+                if (!proxyReady) {
+                    console.error("Proxy exited unexpectedly");
+                    decrementRefCount();
+                    process.exit(code || 1);
                 }
             });
-            serverProcess.on("error", (err) => {
-                console.error("Failed to start server:", err);
+        }
+        // Start analysis server
+        if (!requiresAnalysis) {
+            analysisReady = true;
+        }
+        else if (analysisAlreadyRunning) {
+            analysisReady = true;
+        }
+        else {
+            const analysisPath = join(__dirname, "analysis", "server.js");
+            analysisProcess = spawn("node", [analysisPath], {
+                stdio: ["ignore", "pipe", "pipe"],
+                detached: false,
+                env: serverEnv,
+            });
+            analysisProcess.stdout?.on("data", (data) => {
+                const output = data.toString();
+                if (!analysisReady)
+                    process.stderr.write(output);
+                if (output.includes("Context Lens Analysis running") &&
+                    !analysisReady) {
+                    analysisReady = true;
+                    checkBothReady();
+                }
+            });
+            analysisProcess.stderr?.on("data", (data) => {
+                if (!analysisReady)
+                    process.stderr.write(data);
+            });
+            analysisProcess.on("error", (err) => {
+                console.error("Failed to start analysis server:", err);
                 decrementRefCount();
                 process.exit(1);
             });
-            serverProcess.on("exit", (code) => {
-                if (!serverReady) {
-                    console.error("Server exited unexpectedly");
+            analysisProcess.on("exit", (code) => {
+                if (!analysisReady) {
+                    console.error("Analysis server exited unexpectedly");
                     decrementRefCount();
                     process.exit(code || 1);
                 }
             });
-            // Open browser after a short delay (only when starting new server)
+        }
+        // Open browser after a short delay (only when starting new servers)
+        if (!noOpen && requiresAnalysis) {
             setTimeout(() => {
                 openBrowser("http://localhost:4041");
             }, 1000);
         }
+        // If both were already ready (mixed scenario), check now
+        checkBothReady();
     }
-    initializeProxy();
+    initializeServers();
     // Start mitmproxy if needed, then start the child
     function maybeStartMitmThenChild() {
         if (!toolConfig.needsMitm) {
@@ -241,6 +355,16 @@ else {
             ...process.env,
             ...toolConfig.childEnv,
         };
+        // Fill in mitmproxy CA cert path for tools that need HTTPS interception
+        if (toolConfig.needsMitm && childEnv.SSL_CERT_FILE === "") {
+            const certPath = join(homedir(), ".mitmproxy", "mitmproxy-ca-cert.pem");
+            if (fs.existsSync(certPath)) {
+                childEnv.SSL_CERT_FILE = certPath;
+            }
+            else {
+                console.error(`Warning: mitmproxy CA cert not found at ${certPath}. Run 'mitmdump' once to generate it.`);
+            }
+        }
         if (commandName === "pi") {
             childEnv.PI_CODING_AGENT_DIR = preparePiAgentDir(childEnv.PI_CODING_AGENT_DIR);
         }
@@ -251,6 +375,13 @@ else {
             env: childEnv,
         });
         childProcess.on("error", (err) => {
+            if (err.code === "ENOENT") {
+                console.error(`\nFailed to start '${commandName}': command not found.`);
+                console.error("Try a known tool (claude, codex, gemini, aider, pi) or use:");
+                console.error("  context-lens -- <your-command> [args...]");
+                cleanup(127);
+                return;
+            }
             console.error(`\nFailed to start ${commandName}:`, err.message);
             cleanup(1);
         });
@@ -417,11 +548,11 @@ else {
                 console.error("Warning: failed to clean up temporary Pi config dir:", err instanceof Error ? err.message : String(err));
             }
         }
-        if (remainingRefs === 0 &&
-            shouldShutdownProxy &&
-            serverProcess &&
-            !serverProcess.killed) {
-            serverProcess.kill();
+        if (remainingRefs === 0 && shouldShutdownServers) {
+            if (proxyProcess && !proxyProcess.killed)
+                proxyProcess.kill();
+            if (analysisProcess && !analysisProcess.killed)
+                analysisProcess.kill();
         }
         process.exit(exitCode);
     }
@@ -434,4 +565,414 @@ else {
             childProcess.kill("SIGTERM");
     });
 }
+function getBackgroundStatePath() {
+    return join(homedir(), ".context-lens", "background.json");
+}
+function ensureContextLensDir() {
+    fs.mkdirSync(join(homedir(), ".context-lens"), { recursive: true });
+}
+function readBackgroundState() {
+    try {
+        const raw = fs.readFileSync(getBackgroundStatePath(), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed &&
+            typeof parsed === "object" &&
+            typeof parsed.proxyPid === "number" &&
+            (typeof parsed.analysisPid === "number" || parsed.analysisPid === null) &&
+            typeof parsed.noUi === "boolean" &&
+            typeof parsed.startedAt === "string") {
+            return parsed;
+        }
+    }
+    catch { }
+    return null;
+}
+function writeBackgroundState(state) {
+    ensureContextLensDir();
+    fs.writeFileSync(getBackgroundStatePath(), `${JSON.stringify(state, null, 2)}\n`);
+}
+function clearBackgroundState() {
+    try {
+        fs.unlinkSync(getBackgroundStatePath());
+    }
+    catch { }
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isBackgroundRunning(state) {
+    const proxyAlive = isPidAlive(state.proxyPid);
+    const analysisAlive = state.analysisPid == null || isPidAlive(state.analysisPid);
+    return proxyAlive && analysisAlive;
+}
+function parseBackgroundArgs(args, globalNoUi) {
+    const actionArg = args[0] || "status";
+    if (!["start", "stop", "status"].includes(actionArg)) {
+        return {
+            error: "Error: background command requires one of: start, stop, status",
+        };
+    }
+    const localNoUi = args.includes("--no-ui");
+    return {
+        action: actionArg,
+        noUi: globalNoUi || localNoUi,
+    };
+}
+async function runBackgroundCommand(args, globalNoUi) {
+    const parsed = parseBackgroundArgs(args, globalNoUi);
+    if ("error" in parsed) {
+        console.error(parsed.error);
+        return 1;
+    }
+    if (parsed.action === "status") {
+        return backgroundStatus();
+    }
+    if (parsed.action === "stop") {
+        return backgroundStop();
+    }
+    return backgroundStart(parsed.noUi);
+}
+function backgroundStatus() {
+    const state = readBackgroundState();
+    if (!state) {
+        console.log("Background status: not running");
+        return 0;
+    }
+    const running = isBackgroundRunning(state);
+    if (!running) {
+        console.log("Background status: stale state found (not running)");
+        clearBackgroundState();
+        return 0;
+    }
+    console.log("Background status: running");
+    console.log(`  proxy pid: ${state.proxyPid}`);
+    if (state.analysisPid != null) {
+        console.log(`  analysis pid: ${state.analysisPid}`);
+    }
+    else {
+        console.log("  analysis: disabled (--no-ui)");
+    }
+    console.log(`  started: ${state.startedAt}`);
+    return 0;
+}
+function backgroundStop() {
+    const state = readBackgroundState();
+    if (!state) {
+        console.log("Background status: not running");
+        return 0;
+    }
+    const pids = [state.proxyPid, state.analysisPid].filter((pid) => pid != null);
+    for (const pid of pids) {
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch { }
+    }
+    clearBackgroundState();
+    console.log("Background services stopped.");
+    return 0;
+}
+async function backgroundStart(noUi) {
+    const existing = readBackgroundState();
+    if (existing && isBackgroundRunning(existing)) {
+        console.log("Background status: already running");
+        console.log(`  proxy pid: ${existing.proxyPid}`);
+        return 0;
+    }
+    if (existing)
+        clearBackgroundState();
+    const proxyPath = join(__dirname, "proxy", "server.js");
+    const proxy = spawn("node", [proxyPath], {
+        stdio: "ignore",
+        detached: true,
+        env: { ...process.env, CONTEXT_LENS_CLI: "1" },
+    });
+    proxy.unref();
+    let analysis = null;
+    if (!noUi) {
+        const analysisPath = join(__dirname, "analysis", "server.js");
+        analysis = spawn("node", [analysisPath], {
+            stdio: "ignore",
+            detached: true,
+            env: { ...process.env, CONTEXT_LENS_CLI: "1" },
+        });
+        analysis.unref();
+    }
+    // Give children a brief chance to fail immediately (e.g. command not found).
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const proxyPid = proxy.pid ?? 0;
+    const analysisPid = analysis?.pid ?? null;
+    if (!proxyPid || !isPidAlive(proxyPid)) {
+        console.error("Failed to start proxy in background.");
+        return 1;
+    }
+    if (analysisPid != null && !isPidAlive(analysisPid)) {
+        console.error("Failed to start analysis server in background.");
+        try {
+            process.kill(proxyPid, "SIGTERM");
+        }
+        catch { }
+        return 1;
+    }
+    writeBackgroundState({
+        proxyPid,
+        analysisPid,
+        noUi,
+        startedAt: new Date().toISOString(),
+    });
+    console.log("Background services started.");
+    console.log(`  proxy: http://localhost:4040 (pid ${proxyPid})`);
+    if (analysisPid != null) {
+        console.log(`  analysis/web UI: http://localhost:4041 (pid ${analysisPid})`);
+    }
+    else {
+        console.log("  analysis/web UI: disabled (--no-ui)");
+    }
+    return 0;
+}
+async function isPortListening(port) {
+    return await new Promise((resolve) => {
+        const socket = net.connect({ port, host: "localhost" }, () => {
+            socket.end();
+            resolve(true);
+        });
+        socket.on("error", () => resolve(false));
+        socket.setTimeout(700, () => {
+            socket.destroy();
+            resolve(false);
+        });
+    });
+}
+function findBinaryOnPath(binary) {
+    const pathValue = process.env.PATH || "";
+    const dirs = pathValue.split(":").filter(Boolean);
+    for (const dir of dirs) {
+        const full = join(dir, binary);
+        if (fs.existsSync(full))
+            return full;
+    }
+    return null;
+}
+function checkWritableDir(targetDir) {
+    try {
+        fs.mkdirSync(targetDir, { recursive: true });
+        fs.accessSync(targetDir, fs.constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function runAnalyze(args) {
+    // Lazy import to avoid loading analysis code unless needed
+    const { readLharFile } = await import("./lhar.js");
+    const { analyzeSession, formatSessionAnalysis } = await import("./core.js");
+    // Parse analyze-specific arguments
+    let filepath;
+    let outputJson = false;
+    let mainOnly = false;
+    let showPath = true;
+    let compositionArg;
+    for (const arg of args) {
+        if (arg === "--json") {
+            outputJson = true;
+        }
+        else if (arg === "--main-only") {
+            mainOnly = true;
+        }
+        else if (arg === "--no-path") {
+            showPath = false;
+        }
+        else if (arg.startsWith("--composition=")) {
+            compositionArg = arg.split("=", 1 + 1)[1];
+        }
+        else if (arg === "--help" || arg === "-h") {
+            console.log([
+                "Usage: context-lens analyze <session.lhar> [options]",
+                "",
+                "Analyze an LHAR session file and print detailed statistics.",
+                "",
+                "Options:",
+                "  --json                    Output as JSON",
+                "  --no-path                 Omit agent path trace",
+                "  --main-only               Only analyze main agent entries",
+                "  --composition=last        Composition of last entry (default)",
+                "  --composition=pre-compaction  Composition before each compaction",
+                "  --composition=N           Composition at end of user turn N",
+            ].join("\n"));
+            return 0;
+        }
+        else if (!arg.startsWith("-")) {
+            filepath = arg;
+        }
+        else {
+            console.error(`Unknown option: ${arg}`);
+            return 1;
+        }
+    }
+    if (!filepath) {
+        console.error("Error: no session file specified. Usage: context-lens analyze <session.lhar>");
+        return 1;
+    }
+    // Resolve filepath: try as-is, then in ~/.context-lens/data/, then in ./data/
+    let resolvedPath = filepath;
+    if (!fs.existsSync(resolvedPath)) {
+        const homeData = join(homedir(), ".context-lens", "data", filepath);
+        const localData = join("data", filepath);
+        if (fs.existsSync(homeData)) {
+            resolvedPath = homeData;
+        }
+        else if (fs.existsSync(localData)) {
+            resolvedPath = localData;
+        }
+        else {
+            console.error(`Error: file not found: ${filepath}`);
+            console.error(`  Searched: ${filepath}, ${homeData}, ${localData}`);
+            return 1;
+        }
+    }
+    try {
+        const { session, entries } = readLharFile(resolvedPath);
+        const basename = resolvedPath.split("/").pop() || resolvedPath;
+        const analysis = analyzeSession(session, entries, basename, { mainOnly });
+        if (outputJson) {
+            console.log(JSON.stringify(analysis, null, 2));
+        }
+        else {
+            const output = formatSessionAnalysis(analysis, {
+                showPath,
+                composition: compositionArg,
+                entries,
+            });
+            console.log(output);
+        }
+        return 0;
+    }
+    catch (err) {
+        console.error(`Error analyzing ${resolvedPath}:`, err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+}
+async function runDoctor() {
+    let hasFailures = false;
+    function report(name, ok, detail) {
+        const mark = ok ? "OK" : "FAIL";
+        console.log(`[${mark}] ${name}: ${detail}`);
+        if (!ok)
+            hasFailures = true;
+    }
+    console.log(`Context Lens doctor v${VERSION}`);
+    report("node", true, process.version);
+    const proxyListening = await isPortListening(4040);
+    report("proxy port :4040", true, proxyListening ? "already running" : "available/not running");
+    const analysisListening = await isPortListening(4041);
+    report("analysis port :4041", true, analysisListening ? "already running" : "available/not running");
+    const mitmdumpPath = findBinaryOnPath("mitmdump");
+    report("mitmdump", !!mitmdumpPath, mitmdumpPath ??
+        "not found (required for Codex; install: pipx install mitmproxy)");
+    const certPath = join(homedir(), ".mitmproxy", "mitmproxy-ca-cert.pem");
+    report("mitm CA cert", fs.existsSync(certPath), fs.existsSync(certPath)
+        ? certPath
+        : `${certPath} (not present; run 'mitmdump' once to generate it)`);
+    const contextDir = join(homedir(), ".context-lens");
+    const dataDir = join(contextDir, "data");
+    report("context dir writable", checkWritableDir(contextDir), contextDir);
+    report("data dir writable", checkWritableDir(dataDir), dataDir);
+    const bg = readBackgroundState();
+    if (!bg) {
+        report("background state", true, "not running");
+    }
+    else {
+        report("background state", isBackgroundRunning(bg), isBackgroundRunning(bg) ? "running" : "stale state file");
+    }
+    const lockfileExists = fs.existsSync(LOCKFILE);
+    report("lockfile", true, lockfileExists ? `${LOCKFILE} present` : `${LOCKFILE} absent`);
+    if (hasFailures) {
+        console.log("Doctor result: issues found.");
+        return 1;
+    }
+    console.log("Doctor result: all checks passed.");
+    return 0;
+}
+function checkForUpdate(currentVersion) {
+    const cachePath = join(homedir(), ".context-lens", "update-check.json");
+    const dayMs = 24 * 60 * 60 * 1000;
+    let cached = null;
+    try {
+        const raw = fs.readFileSync(cachePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed &&
+            typeof parsed === "object" &&
+            typeof parsed.checkedAt === "number" &&
+            typeof parsed.latestVersion === "string") {
+            cached = parsed;
+        }
+    }
+    catch { }
+    if (cached && Date.now() - cached.checkedAt < dayMs) {
+        if (isNewerVersion(cached.latestVersion, currentVersion)) {
+            printUpdateNotice(currentVersion, cached.latestVersion);
+        }
+        return;
+    }
+    const req = https.get("https://registry.npmjs.org/context-lens/latest", { timeout: 1500 }, (res) => {
+        if (res.statusCode !== 200)
+            return;
+        let body = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+            body += chunk;
+        });
+        res.on("end", () => {
+            try {
+                const parsed = JSON.parse(body);
+                if (!parsed.version)
+                    return;
+                const latestVersion = parsed.version;
+                try {
+                    fs.mkdirSync(join(homedir(), ".context-lens"), {
+                        recursive: true,
+                    });
+                    fs.writeFileSync(cachePath, `${JSON.stringify({ checkedAt: Date.now(), latestVersion }, null, 2)}\n`);
+                }
+                catch { }
+                if (isNewerVersion(latestVersion, currentVersion)) {
+                    printUpdateNotice(currentVersion, latestVersion);
+                }
+            }
+            catch { }
+        });
+    });
+    req.on("error", () => { });
+    req.on("timeout", () => req.destroy());
+}
+function isNewerVersion(candidate, current) {
+    const a = splitSemver(candidate);
+    const b = splitSemver(current);
+    for (let i = 0; i < 3; i++) {
+        if (a[i] > b[i])
+            return true;
+        if (a[i] < b[i])
+            return false;
+    }
+    return false;
+}
+function splitSemver(version) {
+    const [major, minor, patch] = version.split(".", 3).map((part) => {
+        const parsed = Number.parseInt(part.replace(/[^0-9].*$/, ""), 10);
+        return Number.isFinite(parsed) ? parsed : 0;
+    });
+    return [major ?? 0, minor ?? 0, patch ?? 0];
+}
+function printUpdateNotice(currentVersion, latestVersion) {
+    console.error(`\nUpdate available: context-lens ${currentVersion} -> ${latestVersion}`);
+    console.error("Run: npm install -g context-lens");
+    console.error("Skip this check: --no-update-check or CONTEXT_LENS_NO_UPDATE_CHECK=1\n");
+}
 //# sourceMappingURL=cli.js.map