litmus-cli 1.0.19 → 1.0.21

package/dist/lib/watcher.js

@@ -0,0 +1,752 @@
+#!/usr/bin/env node
+/**
+ * Litmus file activity watcher.
+ * Runs as a detached background process started by `litmus init`.
+ * Usage: node watcher.js <projectDir> <activityLogPath> [cliBinPath]
+ *
+ * Tracks:
+ * - File changes with size deltas and large-paste detection (debounced 500ms per file)
+ * - Heartbeat events every 5 minutes
+ * - Git commit events (polled every 30s)
+ * - Editor and AI tool detection (polled every 10 min)
+ * - Auto-submit at deadline (if deadline/timeLimit configured)
+ *
+ * Writes newline-delimited JSON to the activity log.
+ */
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { execSync, execFile } from "child_process";
+import dns from "dns";
+import https from "https";
+import http from "http";
+import { getEffectiveDeadline } from "./config.js";
+import { getProcessList, getConnections, extractConnectionIP } from "./platform.js";
+const [, , projectDir, activityLogPath, cliBinPath] = process.argv;
+process.stderr.write(`[watcher] starting: projectDir=${projectDir} log=${activityLogPath}\n`);
+process.stderr.write(`[watcher] node ${process.version}, platform=${process.platform}, arch=${process.arch}\n`);
+if (!projectDir || !activityLogPath) {
+    process.stderr.write("[watcher] missing arguments\n");
+    process.exit(1);
+}
+if (!fs.existsSync(projectDir)) {
+    process.stderr.write(`[watcher] projectDir does not exist: ${projectDir}\n`);
+    process.exit(1);
+}
+// Ensure the log directory exists
+fs.mkdirSync(path.dirname(activityLogPath), { recursive: true });
+// Open the log file for appending
+const log = fs.createWriteStream(activityLogPath, { flags: "a" });
+// ── Config ──────────────────────────────────────────────────────
+let litmusConfig = null;
+try {
+    const configPath = path.join(projectDir, ".litmus", "config.json");
+    litmusConfig = JSON.parse(fs.readFileSync(configPath, "utf8"));
+}
+catch { /* config not available */ }
+let uploadConfig = null;
+let uploadBuffer = [];
+const MAX_BUFFER_SIZE = 10000;
+if (litmusConfig && litmusConfig.token && litmusConfig.backendUrl) {
+    uploadConfig = { token: litmusConfig.token, backendUrl: litmusConfig.backendUrl };
+    process.stderr.write("[watcher] upload enabled\n");
+}
+/**
+ * Upload buffered events to server.
+ * Returns a Promise that resolves when the HTTP request completes (used by shutdown).
+ * During normal operation the returned promise is ignored (fire-and-forget).
+ */
+function uploadEvents() {
+    if (!uploadConfig || uploadBuffer.length === 0)
+        return Promise.resolve();
+    const events = uploadBuffer.splice(0); // take all, clear buffer
+    const body = JSON.stringify({ events });
+    const url = new URL(`${uploadConfig.backendUrl}/cli/activity`);
+    const reqFn = url.protocol === "https:" ? https.request : http.request;
+    return new Promise((resolve) => {
+        const req = reqFn(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(body),
+                "Authorization": `Bearer ${uploadConfig.token}`,
+            },
+            timeout: 10000,
+        }, (res) => {
+            // Collect response body (for pendingQuestions and other server signals)
+            let responseData = "";
+            res.on("data", (chunk) => { responseData += chunk.toString(); });
+            res.on("end", () => {
+                if (res.statusCode >= 500) {
+                    process.stderr.write(`[watcher] upload failed (will retry): ${res.statusCode}\n`);
+                    uploadBuffer = events.concat(uploadBuffer);
+                    if (uploadBuffer.length > MAX_BUFFER_SIZE) {
+                        uploadBuffer = uploadBuffer.slice(-MAX_BUFFER_SIZE);
+                    }
+                }
+                else if (res.statusCode >= 400) {
+                    process.stderr.write(`[watcher] upload rejected: ${res.statusCode}\n`);
+                }
+                else {
+                    // Parse response for server signals (e.g., pending questions)
+                    try {
+                        const body = JSON.parse(responseData);
+                        if (body.pendingQuestions && body.pendingQuestions > 0) {
+                            const nudgePath = path.join(projectDir, ".litmus", "QUESTION.md");
+                            const nudge = `# You have ${body.pendingQuestions} unanswered question${body.pendingQuestions > 1 ? "s" : ""}\n\nPlease check your Litmus browser tab to view and answer.\n`;
+                            try {
+                                fs.writeFileSync(nudgePath, nudge, "utf8");
+                            }
+                            catch { /* non-critical */ }
+                            process.stderr.write(`[litmus] ${body.pendingQuestions} unanswered question(s) — check your browser tab\n`);
+                        }
+                        else {
+                            // Clean up nudge file if no pending questions
+                            const nudgePath = path.join(projectDir, ".litmus", "QUESTION.md");
+                            try {
+                                fs.unlinkSync(nudgePath);
+                            }
+                            catch { /* may not exist */ }
+                        }
+                    }
+                    catch { /* response parse failed, non-critical */ }
+                }
+                resolve();
+            });
+        });
+        req.on("error", () => {
+            // Network error — retry on next heartbeat
+            uploadBuffer = events.concat(uploadBuffer);
+            if (uploadBuffer.length > MAX_BUFFER_SIZE) {
+                uploadBuffer = uploadBuffer.slice(-MAX_BUFFER_SIZE);
+            }
+            resolve();
+        });
+        req.on("timeout", () => { req.destroy(); });
+        req.end(body);
+    });
+}
+// ── Ignore patterns ──────────────────────────────────────────────
+const IGNORED = [
+    /(?:^|[/\\])\./, // dotfiles and dotdirs (including .git, .litmus)
+    /node_modules/,
+    /__pycache__/,
+    /\.pyc$/,
+    /\.class$/,
+    /(?:^|[/\\])venv[/\\]/,
+    /(?:^|[/\\])\.venv[/\\]/,
+];
+function shouldIgnore(relPath) {
+    return IGNORED.some((re) => re.test(relPath));
+}
+// ── Hash chain for tamper evidence ──────────────────────────────
+let prevHash = "0".repeat(64); // genesis
+let nextSeq = 0;
+function emit(event) {
+    event._seq = nextSeq++;
+    event._prevHash = prevHash;
+    const hash = crypto.createHash("sha256").update(JSON.stringify(event)).digest("hex");
+    event._hash = hash;
+    prevHash = hash;
+    log.write(JSON.stringify(event) + "\n");
+    if (uploadConfig && uploadBuffer.length < MAX_BUFFER_SIZE) {
+        uploadBuffer.push(event);
+    }
+}
+// ── File size tracking ───────────────────────────────────────────
+const LARGE_PASTE_THRESHOLD = 5000; // bytes — matches backend constant
+const fileSizes = new Map();
+const debounceTimers = new Map();
+function emitFileEvent(type, relPath) {
+    const fullPath = path.join(projectDir, relPath);
+    const event = { ts: new Date().toISOString(), type, path: relPath };
+    try {
+        const stat = fs.statSync(fullPath);
+        const fileSize = stat.size;
+        event.fileSize = fileSize;
+        const prev = fileSizes.get(relPath);
+        const sizeDelta = prev !== undefined ? fileSize - prev : fileSize;
+        event.sizeDelta = sizeDelta;
+        fileSizes.set(relPath, fileSize);
+        if (sizeDelta > LARGE_PASTE_THRESHOLD) {
+            event.largePaste = true;
+            event.bytesAdded = sizeDelta;
+        }
+    }
+    catch {
+        // File was deleted or unreadable — still log the event, just without size data
+        fileSizes.delete(relPath);
+    }
+    emit(event);
+}
+// ── Burst-edit detection (AI-driven multi-file edits) ────────────
+const BURST_WINDOW_MS = 2000; // 2 seconds
+const BURST_MIN_FILES = 3; // 3+ distinct files = burst
+const recentEdits = [];
+function checkBurstEdit(filename) {
+    const now = Date.now();
+    recentEdits.push({ file: filename, ts: now });
+    // Prune edits outside the window
+    while (recentEdits.length > 0 && now - recentEdits[0].ts > BURST_WINDOW_MS) {
+        recentEdits.shift();
+    }
+    // Count distinct files in the window
+    const distinctFiles = new Set(recentEdits.map((e) => e.file));
+    if (distinctFiles.size >= BURST_MIN_FILES) {
+        const files = [...distinctFiles];
+        emit({
+            ts: new Date().toISOString(),
+            type: "burst_edit",
+            fileCount: files.length,
+            files: files.slice(0, 10), // Cap at 10 filenames
+        });
+        recentEdits.length = 0; // Reset to avoid duplicate bursts
+    }
+}
+// ── File system watcher (debounced) ──────────────────────────────
+process.on("uncaughtException", (err) => {
+    process.stderr.write(`[watcher] uncaughtException: ${err.stack || err}\n`);
+    process.exit(1);
+});
+try {
+    const watcher = fs.watch(projectDir, { recursive: true }, (eventType, filename) => {
+        if (!filename)
+            return;
+        // Check for AI artifact files before applying ignore filter (artifacts are dotfiles)
+        checkArtifact(filename);
+        if (shouldIgnore(filename))
+            return;
+        // Check for burst edits on raw events (before debounce — needs real timing)
+        checkBurstEdit(filename);
+        // Debounce per file: collapse multiple events within 500ms into one
+        if (debounceTimers.has(filename)) {
+            clearTimeout(debounceTimers.get(filename));
+        }
+        debounceTimers.set(filename, setTimeout(() => {
+            debounceTimers.delete(filename);
+            emitFileEvent(eventType, filename);
+        }, 500));
+    });
+    watcher.on("error", (err) => {
+        process.stderr.write(`[watcher] fs.watch error: ${err}\n`);
+    });
+    process.stderr.write("[watcher] file watcher started\n");
+}
+catch (err) {
+    // fs.watch with recursive: true is not supported on Linux < Node 22.
+    // Continue without file watching — heartbeats and git commit polling still work.
+    process.stderr.write(`[watcher] file watching unavailable: ${err.message} (heartbeat + git tracking still active)\n`);
+}
+// ── Heartbeats ───────────────────────────────────────────────────
+function emitHeartbeat() {
+    emit({ ts: new Date().toISOString(), type: "heartbeat" });
+    uploadEvents(); // Upload buffered events to server
+}
+emitHeartbeat(); // Immediate heartbeat + initial upload
+setInterval(emitHeartbeat, 5 * 60 * 1000); // Every 5 minutes
+// ── Git commit polling ───────────────────────────────────────────
+let lastCommitHash = null;
+function readCurrentCommitHash() {
+    try {
+        const headContent = fs.readFileSync(path.join(projectDir, ".git", "HEAD"), "utf8").trim();
+        if (headContent.startsWith("ref: ")) {
+            const ref = headContent.slice(5);
+            const refPath = path.join(projectDir, ".git", ref);
+            // Try loose ref first, then fall back to packed-refs
+            if (fs.existsSync(refPath)) {
+                return fs.readFileSync(refPath, "utf8").trim();
+            }
+            const packedPath = path.join(projectDir, ".git", "packed-refs");
+            if (fs.existsSync(packedPath)) {
+                const packed = fs.readFileSync(packedPath, "utf8");
+                for (const line of packed.split("\n")) {
+                    if (line.endsWith(" " + ref)) {
+                        return line.split(" ")[0];
+                    }
+                }
+            }
+        }
+        else {
+            return headContent; // Detached HEAD — the hash itself
+        }
+    }
+    catch { /* .git may not exist */ }
+    return null;
+}
+// Initialize with current commit hash
+lastCommitHash = readCurrentCommitHash();
+function checkGitCommits() {
+    try {
+        const currentHash = readCurrentCommitHash();
+        if (!currentHash || currentHash === lastCommitHash)
+            return;
+        lastCommitHash = currentHash;
+        const info = execSync('git log -1 --numstat --pretty=format:"%H|%aI|%s"', { cwd: projectDir, timeout: 5000, encoding: "utf8" });
+        const lines = info.trim().split("\n");
+        const header = lines[0].replace(/^"|"$/g, "");
+        const firstPipe = header.indexOf("|");
+        const secondPipe = header.indexOf("|", firstPipe + 1);
+        const hash = header.slice(0, firstPipe);
+        const message = secondPipe >= 0 ? header.slice(secondPipe + 1) : "";
+        let linesAdded = 0, linesDeleted = 0, filesChanged = 0;
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i].trim();
+            if (!line)
+                continue;
+            const parts = line.split("\t");
+            if (parts[0] !== "-")
+                linesAdded += parseInt(parts[0], 10) || 0;
+            if (parts[1] !== "-")
+                linesDeleted += parseInt(parts[1], 10) || 0;
+            filesChanged++;
+        }
+        emit({
+            ts: new Date().toISOString(),
+            type: "commit",
+            hash: hash ? hash.slice(0, 12) : currentHash.slice(0, 12),
+            message: message || "",
+            linesAdded,
+            linesDeleted,
+            filesChanged,
+        });
+    }
+    catch { /* git not available or command failed — skip */ }
+}
+setInterval(checkGitCommits, 30 * 1000); // Every 30 seconds
+// ── Editor & AI tool detection ───────────────────────────────────
+const EDITOR_PATTERNS = {
+    vscode: /\bcode\b/,
+    cursor: /\bcursor\b/,
+    vim: /\b[gn]?vim\b/,
+    intellij: /\bidea\b/,
+    webstorm: /\bwebstorm\b/,
+    sublime: /\bsubl\b/,
+    emacs: /\bemacs\b/,
+    zed: /\bzed\b/,
+};
+const AI_TOOL_PATTERNS = {
+    claude: /\bclaude\b/,
+    aider: /\baider\b/,
+    codeium: /\bcodeium\b/,
+    codex: /\bcodex\b/,
+    copilot: /\bcopilot\b/,
+    windsurf: /\bwindsurf\b/,
+    ollama: /\bollama\b/,
+    tabnine: /\btabnine\b/,
+    supermaven: /\bsupermaven\b/,
+    cline: /\bcline\b/,
+    cody: /\bsourcegraph-cody\b|\bcody-agent\b/,
+    "amazon-q": /\bamazon-q\b/,
+    "roo-code": /\broo-code\b|\broo_code\b/,
+    pearai: /\bpearai\b/,
+    ghostwriter: /\bghostwriter\b/,
+};
+function detectEnvironment() {
+    try {
+        const ps = getProcessList();
+        const editors = Object.entries(EDITOR_PATTERNS)
+            .filter(([, re]) => re.test(ps))
+            .map(([name]) => name);
+        const aiTools = Object.entries(AI_TOOL_PATTERNS)
+            .filter(([, re]) => re.test(ps))
+            .map(([name]) => name);
+        // Cursor is both an editor and an AI tool
+        if (editors.includes("cursor") && !aiTools.includes("cursor")) {
+            aiTools.push("cursor");
+        }
+        if (editors.length > 0 || aiTools.length > 0) {
+            const event = { ts: new Date().toISOString(), type: "env_detected" };
+            if (editors.length)
+                event.editors = editors;
+            if (aiTools.length)
+                event.aiTools = aiTools;
+            emit(event);
+        }
+    }
+    catch { /* process listing may fail, skip */ }
+}
+detectEnvironment(); // Run immediately on startup
+setInterval(detectEnvironment, 10 * 60 * 1000); // Every 10 minutes
+// ── AI artifact file detection ──────────────────────────────────
+const AI_ARTIFACT_PATTERNS = [
+    { tool: "cursor", paths: [".cursorrules", ".cursorignore"] },
+    { tool: "windsurf", paths: [".windsurfrules"] },
+    { tool: "aider", paths: [".aider.chat.history.md", ".aider.input.history", ".aider.tags.cache"] },
+    { tool: "continue", paths: [".continue"] },
+    { tool: "codeium", paths: [".codeium"] },
+    { tool: "tabnine", paths: [".tabnine"] },
+    { tool: "codex", paths: ["codex.md", ".codex"] },
+];
+const seenArtifacts = new Set();
+function checkArtifact(relPath) {
+    if (seenArtifacts.has(relPath))
+        return;
+    for (const { tool, paths } of AI_ARTIFACT_PATTERNS) {
+        for (const p of paths) {
+            if (relPath === p || relPath.startsWith(p + "/") || relPath.startsWith(p + "\\")) {
+                seenArtifacts.add(relPath);
+                emit({
+                    ts: new Date().toISOString(),
+                    type: "ai_artifact_detected",
+                    tool,
+                    file: relPath,
+                });
+                return;
+            }
+        }
+    }
+}
+// Startup scan for pre-existing artifacts
+for (const { tool, paths } of AI_ARTIFACT_PATTERNS) {
+    for (const p of paths) {
+        try {
+            if (fs.existsSync(path.join(projectDir, p))) {
+                seenArtifacts.add(p);
+                emit({
+                    ts: new Date().toISOString(),
+                    type: "ai_artifact_detected",
+                    tool,
+                    file: p,
+                });
+            }
+        }
+        catch { /* skip */ }
+    }
+}
+// ── Network monitoring (AI API endpoint detection) ──────────────
+const AI_NETWORK_HOSTS = {
+    "api.openai.com": "openai",
+    "chat.openai.com": "chatgpt",
+    "chatgpt.com": "chatgpt",
+    "api.anthropic.com": "claude_api",
+    "claude.ai": "claude_web",
+    "generativelanguage.googleapis.com": "gemini_api",
+    "gemini.google.com": "gemini_web",
+    "copilot-proxy.githubusercontent.com": "copilot",
+    "githubcopilot.com": "copilot",
+    "api2.cursor.sh": "cursor",
+    "cursor.sh": "cursor",
+    "server.codeium.com": "codeium",
+    "api.perplexity.ai": "perplexity",
+    "perplexity.ai": "perplexity",
+    "api.deepseek.com": "deepseek",
+    "api.groq.com": "groq",
+    "api.mistral.ai": "mistral",
+};
+// IP -> tool name cache (refreshed every 30 min)
+const ipToTool = new Map();
+let lastDnsRefresh = 0;
+const DNS_REFRESH_MS = 30 * 60 * 1000;
+function refreshDnsCache() {
+    lastDnsRefresh = Date.now();
+    for (const [host, tool] of Object.entries(AI_NETWORK_HOSTS)) {
+        dns.resolve4(host, (err, addresses) => {
+            if (!err && addresses) {
+                for (const ip of addresses) {
+                    ipToTool.set(ip, { tool, host });
+                }
+            }
+        });
+    }
+}
+refreshDnsCache(); // Resolve on startup
+let lastNetworkTools = ""; // Dedup: JSON stringified tool set from previous check
+function detectNetworkAI() {
+    if (Date.now() - lastDnsRefresh > DNS_REFRESH_MS)
+        refreshDnsCache();
+    if (ipToTool.size === 0)
+        return; // DNS hasn't resolved yet
+    getConnections((err, stdout) => {
+        if (err || !stdout)
+            return;
+        parseNetworkOutput(stdout);
+    });
+}
+function parseNetworkOutput(output) {
+    const detected = new Map(); // tool -> Set<host>
+    for (const line of output.split("\n")) {
+        const ipMatch = extractConnectionIP(line);
+        if (!ipMatch)
+            continue;
+        const ip = ipMatch[1];
+        const entry = ipToTool.get(ip);
+        if (entry) {
+            if (!detected.has(entry.tool))
+                detected.set(entry.tool, new Set());
+            detected.get(entry.tool).add(entry.host);
+        }
+    }
+    if (detected.size === 0)
+        return;
+    // Dedup: don't re-emit if same tools detected as last check
+    const toolKey = JSON.stringify([...detected.keys()].sort());
+    if (toolKey === lastNetworkTools)
+        return;
+    lastNetworkTools = toolKey;
+    const tools = [];
+    const hosts = [];
+    for (const [tool, hostSet] of detected) {
+        tools.push(tool);
+        for (const h of hostSet)
+            hosts.push(h);
+    }
+    emit({
+        ts: new Date().toISOString(),
+        type: "network_ai_detected",
+        tools,
+        hosts,
+    });
+}
+detectNetworkAI(); // Run immediately
+setInterval(detectNetworkAI, 5 * 60 * 1000); // Every 5 minutes
+// ── Codebase snapshot upload (for live interview agent) ──────────
+const SNAPSHOT_INTERVAL_MS = 5 * 60 * 1000; // Every 5 minutes
+const MAX_FILE_SIZE_BYTES = 50000; // Skip files > 50KB
+const MAX_TOTAL_SNAPSHOT_BYTES = 2000000; // Cap total snapshot at 2MB
+const SNAPSHOT_IGNORE = [
+    /(?:^|[/\\])\./, // dotfiles/dotdirs (.git, .litmus, .env)
+    /node_modules/,
+    /__pycache__/,
+    /\.pyc$/,
+    /\.class$/,
+    /\.jar$/,
+    /\.exe$/,
+    /\.dll$/,
+    /\.so$/,
+    /\.dylib$/,
+    /\.wasm$/,
+    /\.png$/,
+    /\.jpg$/,
+    /\.jpeg$/,
+    /\.gif$/,
+    /\.svg$/,
+    /\.ico$/,
+    /\.mp4$/,
+    /\.mp3$/,
+    /\.zip$/,
+    /\.tar$/,
+    /\.gz$/,
+    /(?:^|[/\\])venv[/\\]/,
+    /(?:^|[/\\])\.venv[/\\]/,
+    /(?:^|[/\\])dist[/\\]/,
+    /(?:^|[/\\])build[/\\]/,
+    /package-lock\.json$/,
+    /yarn\.lock$/,
+    /pnpm-lock\.yaml$/,
+];
+function shouldIgnoreForSnapshot(relPath) {
+    return SNAPSHOT_IGNORE.some((re) => re.test(relPath));
+}
+function collectProjectFiles() {
+    const files = {};
+    let totalBytes = 0;
+    function walk(dir, prefix) {
+        if (totalBytes >= MAX_TOTAL_SNAPSHOT_BYTES)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (totalBytes >= MAX_TOTAL_SNAPSHOT_BYTES)
+                break;
+            const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (shouldIgnoreForSnapshot(relPath))
+                continue;
+            if (entry.isDirectory()) {
+                walk(path.join(dir, entry.name), relPath);
+            }
+            else if (entry.isFile()) {
+                try {
+                    const stat = fs.statSync(path.join(dir, entry.name));
+                    if (stat.size > MAX_FILE_SIZE_BYTES)
+                        continue;
+                    if (totalBytes + stat.size > MAX_TOTAL_SNAPSHOT_BYTES)
+                        continue;
+                    const content = fs.readFileSync(path.join(dir, entry.name), "utf8");
+                    files[relPath] = content;
+                    totalBytes += stat.size;
+                }
+                catch { /* binary or unreadable, skip */ }
+            }
+        }
+    }
+    walk(projectDir, "");
+    return files;
+}
+function getGitDiff() {
+    try {
+        return execSync("git diff HEAD~1 HEAD --stat --patch", {
+            cwd: projectDir,
+            maxBuffer: 500000,
+            timeout: 10000,
+        }).toString().slice(0, 200000);
+    }
+    catch {
+        // No previous commit or git not available
+        try {
+            return execSync("git diff --cached --stat --patch", {
+                cwd: projectDir,
+                maxBuffer: 500000,
+                timeout: 10000,
+            }).toString().slice(0, 200000);
+        }
+        catch {
+            return "";
+        }
+    }
+}
+function getRecentCommits() {
+    try {
+        const raw = execSync("git log --oneline --shortstat -10", {
+            cwd: projectDir,
+            maxBuffer: 100000,
+            timeout: 10000,
+        }).toString();
+        const commits = [];
+        const lines = raw.split("\n");
+        let current = null;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            // Commit line: "abc1234 commit message"
+            const commitMatch = trimmed.match(/^([0-9a-f]{7,}) (.+)$/);
+            if (commitMatch) {
+                if (current)
+                    commits.push(current);
+                current = { hash: commitMatch[1], message: commitMatch[2], linesAdded: 0, linesDeleted: 0 };
+                continue;
+            }
+            // Stats line: "3 files changed, 45 insertions(+), 12 deletions(-)"
+            if (current && trimmed.includes("file")) {
+                const addMatch = trimmed.match(/(\d+) insertion/);
+                const delMatch = trimmed.match(/(\d+) deletion/);
+                if (addMatch)
+                    current.linesAdded = parseInt(addMatch[1]);
+                if (delMatch)
+                    current.linesDeleted = parseInt(delMatch[1]);
+            }
+        }
+        if (current)
+            commits.push(current);
+        return commits;
+    }
+    catch {
+        return [];
+    }
+}
+function uploadSnapshot() {
+    if (!uploadConfig)
+        return;
+    const files = collectProjectFiles();
+    const fileCount = Object.keys(files).length;
+    if (fileCount === 0)
+        return;
+    const gitDiff = getGitDiff();
+    const recentCommits = getRecentCommits();
+    const body = JSON.stringify({ files, git_diff: gitDiff, recent_commits: recentCommits });
+    const url = new URL(`${uploadConfig.backendUrl}/cli/snapshot`);
+    const reqFn = url.protocol === "https:" ? https.request : http.request;
+    const req = reqFn(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(body),
+            "Authorization": `Bearer ${uploadConfig.token}`,
+        },
+        timeout: 30000, // 30s — snapshots can be larger
+    }, (res) => {
+        res.resume(); // Drain response
+        res.on("end", () => {
+            if (res.statusCode >= 400) {
+                process.stderr.write(`[watcher] snapshot upload failed: ${res.statusCode}\n`);
+            }
+            else {
+                process.stderr.write(`[watcher] snapshot uploaded: ${fileCount} files, ${(Buffer.byteLength(body) / 1024).toFixed(0)}KB\n`);
+            }
+        });
+    });
+    req.on("error", () => {
+        process.stderr.write("[watcher] snapshot upload error (network)\n");
+    });
+    req.on("timeout", () => { req.destroy(); });
+    req.end(body);
+}
+// First snapshot after 60s, then on interval
+setTimeout(() => {
+    uploadSnapshot();
+    setInterval(uploadSnapshot, SNAPSHOT_INTERVAL_MS);
+}, 60 * 1000);
+// ── Auto-submit at deadline ──────────────────────────────────────
+if (cliBinPath && litmusConfig) {
+    const effectiveDeadline = getEffectiveDeadline(litmusConfig);
+    if (effectiveDeadline !== null) {
+        const msUntilDeadline = effectiveDeadline - Date.now();
+        const MAX_TIMEOUT = 2147483647; // setTimeout max (2^31 - 1 ms, ~24.8 days)
+        if (msUntilDeadline > 0 && msUntilDeadline <= MAX_TIMEOUT) {
+            process.stderr.write(`[watcher] deadline timer set for ${new Date(effectiveDeadline).toISOString()} (${Math.round(msUntilDeadline / 1000)}s)\n`);
+            setTimeout(() => {
+                process.stderr.write("[watcher] deadline reached, auto-submitting\n");
+                execFile(process.execPath, [cliBinPath, "submit", "--yes"], { cwd: projectDir, timeout: 5 * 60000 }, (err, _stdout, stderr) => {
+                    if (!err) {
+                        process.stderr.write("[watcher] auto-submit succeeded\n");
+                        emit({ ts: new Date().toISOString(), type: "auto_submit" });
+                    }
+                    else {
+                        process.stderr.write(`[watcher] auto-submit failed: ${stderr || err.message}\n`);
+                        emit({ ts: new Date().toISOString(), type: "auto_submit_failed", error: (stderr || err.message).slice(0, 500) });
+                    }
+                });
+            }, msUntilDeadline);
+        }
+        else if (msUntilDeadline > MAX_TIMEOUT) {
+            process.stderr.write(`[watcher] deadline too far in the future (${Math.round(msUntilDeadline / 86400000)}d), skipping auto-submit timer\n`);
+        }
+        else {
+            process.stderr.write("[watcher] deadline already passed, skipping auto-submit\n");
+        }
+    }
+}
+// ── Graceful shutdown ────────────────────────────────────────────
+let shuttingDown = false;
+const shutdownFile = path.join(projectDir, ".litmus", "shutdown");
+function shutdown() {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    // Clean up sentinel file if it exists
+    try {
+        fs.unlinkSync(shutdownFile);
+    }
+    catch { /* may not exist */ }
+    // Flush buffered events to server, then close log and exit
+    const done = () => log.end(() => process.exit(0));
+    const uploadPromise = uploadEvents();
+    if (uploadPromise) {
+        uploadPromise.then(done, done);
+        // Hard exit after 5s if upload hangs
+        setTimeout(() => process.exit(0), 5000).unref();
+    }
+    else {
+        done();
+    }
+}
+// SIGTERM/SIGINT: works on Unix; SIGINT also fires on Windows via Ctrl+C
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+// Sentinel file: cross-platform shutdown mechanism.
+// submit.ts writes .litmus/shutdown → watcher detects it and flushes gracefully.
+// Primary shutdown path on Windows where SIGTERM kills without invoking handlers.
+const sentinelPoll = setInterval(() => {
+    if (fs.existsSync(shutdownFile)) {
+        process.stderr.write("[watcher] shutdown sentinel detected\n");
+        shutdown();
+    }
+}, 1000);
+sentinelPoll.unref(); // Don't keep process alive just for this
+process.stderr.write("[watcher] all monitors started\n");
+//# sourceMappingURL=watcher.js.map