@way_marks/server 4.0.2 → 4.2.0

package/dist/collectors/copilot.js

@@ -0,0 +1,373 @@
+"use strict";
+/**
+ * GitHub Copilot CLI session collector.
+ *
+ * Reads rich session data from ~/.copilot/session-state/<uuid>/:
+ *   - workspace.yaml    — sessionId, cwd, branch, summary (= current task)
+ *   - inuse.<pid>.lock  — active PID
+ *   - events.jsonl      — model, output tokens, tool calls, turn count
+ *
+ * Event types parsed:
+ *   session.start              → startedAt, initial context
+ *   session.model_change       → current model name
+ *   session.compaction_complete → preCompactionTokens (context window usage)
+ *   assistant.message          → outputTokens per turn
+ *   assistant.turn_end         → turn count
+ *   tool.execution_start       → tool calls (name, arg)
+ *   user.message               → last user prompt (current task)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopilotCollector = void 0;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+const process_1 = require("./process");
+/** Minimal flat-YAML parser for Copilot CLI workspace.yaml. */
+function parseWorkspaceYaml(filePath) {
+    try {
+        const text = fs.readFileSync(filePath, 'utf8');
+        const result = {};
+        for (const line of text.split('\n')) {
+            const idx = line.indexOf(': ');
+            if (idx === -1)
+                continue;
+            result[line.slice(0, idx).trim()] = line.slice(idx + 2).trim();
+        }
+        if (!result['id'] || !result['cwd'])
+            return null;
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function applyEvents(acc, events) {
+    for (const e of events) {
+        const ts = e.timestamp ? new Date(e.timestamp).getTime() : 0;
+        const data = e.data ?? {};
+        switch (e.type) {
+            case 'session.start':
+                if (acc.startedAt === 0) {
+                    acc.startedAt = new Date(data.startTime ?? e.timestamp ?? Date.now()).getTime();
+                }
+                break;
+            case 'session.model_change':
+                if (data.newModel)
+                    acc.model = data.newModel;
+                break;
+            case 'session.compaction_complete':
+                if (data.preCompactionTokens) {
+                    acc.contextTokens = data.preCompactionTokens;
+                    acc.compactionCount++;
+                }
+                break;
+            case 'assistant.message':
+                if (data.outputTokens)
+                    acc.totalOutputTokens += data.outputTokens;
+                if (ts) {
+                    acc.lastAssistantMsgMs = ts;
+                    acc.lastActivityMs = ts;
+                }
+                acc.pendingToolCallId = null;
+                break;
+            case 'assistant.turn_end':
+                acc.turnCount++;
+                if (ts)
+                    acc.lastActivityMs = ts;
+                break;
+            case 'tool.execution_start': {
+                const rawName = data.toolName ?? '';
+                const toolName = rawName.includes('.') ? rawName.split('.').pop() ?? rawName : rawName;
+                const args = data.arguments ?? {};
+                const rawArg = args.path ?? args.command ?? args.pattern ?? args.query ?? args.url ?? '';
+                const tc = {
+                    name: toolName || 'unknown',
+                    arg: typeof rawArg === 'string' ? rawArg.slice(0, 120) : '',
+                    durationMs: 0,
+                };
+                acc.toolCalls.push(tc);
+                if (acc.toolCalls.length > 200)
+                    acc.toolCalls = acc.toolCalls.slice(-200);
+                if (ts)
+                    acc.lastActivityMs = ts;
+                acc.pendingToolCallId = data.toolCallId ?? null;
+                break;
+            }
+            case 'tool.execution_complete':
+                if (ts)
+                    acc.lastActivityMs = ts;
+                acc.pendingToolCallId = null;
+                break;
+            case 'user.message': {
+                const content = data.content ?? '';
+                if (content.trim())
+                    acc.currentTask = content.trim().slice(0, 200);
+                if (ts) {
+                    acc.lastUserMsgMs = ts;
+                    acc.lastActivityMs = ts;
+                }
+                break;
+            }
+        }
+    }
+}
+/** Read new lines from a JSONL file starting at startOffset. */
+function readEventsFrom(filePath, startOffset) {
+    try {
+        const stat = fs.statSync(filePath);
+        if (stat.size <= startOffset)
+            return { events: [], newOffset: startOffset };
+        const fd = fs.openSync(filePath, 'r');
+        const bufSize = stat.size - startOffset;
+        const buf = Buffer.alloc(bufSize);
+        const bytesRead = fs.readSync(fd, buf, 0, bufSize, startOffset);
+        fs.closeSync(fd);
+        const text = buf.slice(0, bytesRead).toString('utf8');
+        const lastNl = text.lastIndexOf('\n');
+        if (lastNl === -1)
+            return { events: [], newOffset: startOffset };
+        const chunk = text.slice(0, lastNl);
+        const newOffset = startOffset + Buffer.byteLength(chunk + '\n', 'utf8');
+        const events = [];
+        for (const line of chunk.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                events.push(JSON.parse(line));
+            }
+            catch { /* skip malformed */ }
+        }
+        return { events, newOffset };
+    }
+    catch {
+        return { events: [], newOffset: startOffset };
+    }
+}
+// ─── Collector class ──────────────────────────────────────────────────────────
+class CopilotCollector {
+    /**
+     * @param sessionsDir  Directory holding `<uuid>/` per-session subdirs.
+     *                     Defaults to `~/.copilot/session-state` (Copilot CLI's
+     *                     real location); tests can pass a fixture path.
+     */
+    constructor(sessionsDir = path.join(os.homedir(), '.copilot', 'session-state')) {
+        this.sessionsDir = sessionsDir;
+        this.eventsCache = {};
+    }
+    /**
+     * Collect all live GitHub Copilot CLI sessions.
+     *
+     * Discovery uses lock files at <sessionsDir>/{uuid}/inuse.{PID}.lock rather
+     * than scanning the ps snapshot, giving us access to rich session data.
+     *
+     * @param processInfo  Current ps snapshot (pid to ProcInfo)
+     * @param childrenMap  Parent to children adjacency
+     * @param ports        pid to listening port list
+     * @param gitMap       cwd to {added, modified}
+     */
+    collect(processInfo, childrenMap, ports, gitMap) {
+        const sessionsDir = this.sessionsDir;
+        if (!fs.existsSync(sessionsDir))
+            return [];
+        const sessions = [];
+        let sessionDirs;
+        try {
+            sessionDirs = fs.readdirSync(sessionsDir);
+        }
+        catch {
+            return [];
+        }
+        for (const dirName of sessionDirs) {
+            const sessionDir = path.join(sessionsDir, dirName);
+            const session = this.loadSession(sessionDir, processInfo, childrenMap, ports, gitMap);
+            if (session)
+                sessions.push(session);
+        }
+        this.evictStaleCache(sessions);
+        sessions.sort((a, b) => b.startedAt - a.startedAt);
+        return sessions;
+    }
+    evictStaleCache(sessions) {
+        const activeIds = new Set(sessions.map((s) => s.sessionId));
+        for (const sid of Object.keys(this.eventsCache)) {
+            if (!activeIds.has(sid))
+                delete this.eventsCache[sid];
+        }
+    }
+    loadSession(sessionDir, processInfo, childrenMap, ports, gitMap) {
+        // Require a workspace.yaml
+        const workspacePath = path.join(sessionDir, 'workspace.yaml');
+        if (!fs.existsSync(workspacePath))
+            return null;
+        const meta = parseWorkspaceYaml(workspacePath);
+        if (!meta)
+            return null;
+        // Find any lock file: inuse.<pid>.lock → extract PID
+        let activePid = null;
+        try {
+            for (const f of fs.readdirSync(sessionDir)) {
+                const m = f.match(/^inuse\.(\d+)\.lock$/);
+                if (m) {
+                    activePid = parseInt(m[1], 10);
+                    break;
+                }
+            }
+        }
+        catch {
+            return null;
+        }
+        // Skip sessions with no lock file (completed, not currently running)
+        if (activePid === null)
+            return null;
+        // Confirm the PID is actually alive in the ps snapshot
+        const proc = processInfo.get(activePid);
+        const pidAlive = proc != null;
+        // Parse events.jsonl incrementally
+        const eventsPath = path.join(sessionDir, 'events.jsonl');
+        const sessionId = meta.id;
+        let cached = this.eventsCache[sessionId];
+        if (!cached) {
+            cached = {
+                model: '',
+                startedAt: 0,
+                totalOutputTokens: 0,
+                contextTokens: 0,
+                compactionCount: 0,
+                turnCount: 0,
+                toolCalls: [],
+                currentTask: '',
+                lastActivityMs: 0,
+                lastUserMsgMs: 0,
+                lastAssistantMsgMs: 0,
+                pendingToolCallId: null,
+                newOffset: 0,
+            };
+        }
+        if (fs.existsSync(eventsPath)) {
+            const { events, newOffset } = readEventsFrom(eventsPath, cached.newOffset);
+            if (events.length > 0) {
+                applyEvents(cached, events);
+                cached.newOffset = newOffset;
+            }
+        }
+        this.eventsCache[sessionId] = cached;
+        // Determine status
+        const now = Date.now();
+        const idleSecs = (now - cached.lastActivityMs) / 1000;
+        let status;
+        if (!pidAlive) {
+            status = 'done';
+        }
+        else if (cached.pendingToolCallId) {
+            status = 'executing';
+        }
+        else if (cached.lastUserMsgMs > cached.lastAssistantMsgMs && idleSecs < 60) {
+            status = 'thinking';
+        }
+        else if (idleSecs > 30) {
+            status = 'waiting';
+        }
+        else {
+            status = 'thinking';
+        }
+        // Resolve context window + percent
+        const contextWindow = (0, types_1.contextWindowForModel)(cached.model, cached.contextTokens);
+        const contextPercent = cached.contextTokens > 0
+            ? Math.min(100, Math.round((cached.contextTokens / contextWindow) * 100))
+            : 0;
+        // Current task: prefer workspace summary (set after compaction), else last user message
+        const taskStr = meta.summary || cached.currentTask || '';
+        const currentTasks = taskStr ? [taskStr] : [];
+        // Child processes
+        const childPids = (proc ? childrenMap.get(activePid) ?? [] : []);
+        const children = childPids
+            .map((cpid) => {
+            const cp = processInfo.get(cpid);
+            if (!cp)
+                return null;
+            return {
+                pid: cpid,
+                command: cp.command.split(/\s+/)[0].split('/').pop() ?? cp.command,
+                memKb: cp.rssKb,
+                port: (ports.get(cpid) ?? [])[0],
+            };
+        })
+            .filter((c) => c !== null);
+        // Git stats
+        const cwd = meta.cwd;
+        const git = gitMap.get(cwd) ?? (0, process_1.collectGitStats)(cwd);
+        return {
+            agentCli: 'copilot',
+            pid: activePid,
+            sessionId,
+            cwd,
+            projectName: path.basename(cwd) || cwd,
+            startedAt: cached.startedAt || new Date(meta.created_at || Date.now()).getTime(),
+            status,
+            model: cached.model || 'github-copilot',
+            effort: '',
+            contextPercent,
+            totalInputTokens: 0,
+            totalOutputTokens: cached.totalOutputTokens,
+            totalCacheRead: 0,
+            totalCacheCreate: 0,
+            turnCount: cached.turnCount,
+            currentTasks,
+            memMb: proc ? Math.round(proc.rssKb / 1024) : 0,
+            version: '',
+            gitBranch: meta.branch || '',
+            gitAdded: git.added,
+            gitModified: git.modified,
+            tokenHistory: [],
+            contextHistory: [],
+            compactionCount: cached.compactionCount,
+            contextWindow,
+            subagents: [],
+            memFileCount: 0,
+            memLineCount: 0,
+            children,
+            initialPrompt: currentTasks[0] ?? '',
+            firstAssistantText: '',
+            toolCalls: cached.toolCalls,
+            pendingSinceMs: cached.pendingToolCallId ? cached.lastActivityMs : 0,
+            thinkingSinceMs: cached.lastUserMsgMs > cached.lastAssistantMsgMs ? cached.lastUserMsgMs : 0,
+            fileAccesses: [],
+        };
+    }
+}
+exports.CopilotCollector = CopilotCollector;

package/dist/collectors/multi-collector.js

@@ -0,0 +1,221 @@
+"use strict";
+/**
+ * Multi-collector orchestrator.
+ *
+ * Mirrors abtop/src/collector/mod.rs `MultiCollector`.
+ * Runs Claude and Codex collectors on every tick, staggered so the
+ * expensive operations (lsof, git) only run on slow ticks.
+ *
+ * Usage:
+ *   const mc = new MultiCollector();
+ *   setInterval(() => {
+ *     const snapshot = mc.tick();
+ *     // use snapshot.sessions, snapshot.rateLimits, snapshot.orphanPorts
+ *   }, 2000);
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiCollector = void 0;
+const process_1 = require("./process");
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
+const copilot_1 = require("./copilot");
+const rate_limit_1 = require("./rate-limit");
+const secrets_1 = require("./secrets");
+class MultiCollector {
+    constructor() {
+        this.claude = new claude_1.ClaudeCollector();
+        this.codex = new codex_1.CodexCollector();
+        this.copilot = new copilot_1.CopilotCollector();
+        this.tickCount = 0;
+        /** Ports seen in the previous tick that had a live session behind them. */
+        this.prevSessionPids = new Set();
+        /** Known orphan ports (pid → port[]) persisted across ticks. */
+        this.orphanPortMap = new Map();
+        /** Polling interval config (mirrors abtop defaults). */
+        this.SLOW_TICK_EVERY = 5; // slow tick every 5 fast ticks (= every 10s at 2s interval)
+    }
+    tick() {
+        this.tickCount++;
+        const slowTick = this.tickCount % this.SLOW_TICK_EVERY === 0;
+        // ── Process table (fast tick) ───────────────────────────────────────────
+        const processInfo = (0, process_1.getProcessInfo)();
+        const childrenMap = (0, process_1.getChildrenMap)(processInfo);
+        // ── Ports + git (slow tick only) ─────────────────────────────────────────
+        let ports = new Map();
+        let gitMap = new Map();
+        if (slowTick) {
+            ports = (0, process_1.getListeningPorts)();
+        }
+        // ── Collect sessions ──────────────────────────────────────────────────────
+        const claudeSessions = this.claude.collect(processInfo, childrenMap, ports, gitMap);
+        const codexSessions = this.codex.collect(processInfo, childrenMap, ports, gitMap);
+        const copilotSessions = this.copilot.collect(processInfo, childrenMap, ports, gitMap);
+        const sessions = [...claudeSessions, ...codexSessions, ...copilotSessions];
+        // ── Git stats (slow tick, after session list is known) ────────────────────
+        if (slowTick) {
+            const cwds = new Set(sessions.map((s) => s.cwd));
+            for (const cwd of cwds) {
+                gitMap.set(cwd, (0, process_1.collectGitStats)(cwd));
+            }
+            // Backfill git stats into sessions
+            for (const s of sessions) {
+                const g = gitMap.get(s.cwd);
+                if (g) {
+                    s.gitAdded = g.added;
+                    s.gitModified = g.modified;
+                }
+            }
+        }
+        // ── Rate limits ───────────────────────────────────────────────────────────
+        const rateLimits = [];
+        if (slowTick) {
+            rateLimits.push(...(0, rate_limit_1.readClaudeRateLimits)());
+        }
+        const codexRl = this.codex.lastRateLimit ?? (0, rate_limit_1.readCodexRateLimitCache)();
+        if (codexRl)
+            rateLimits.push(codexRl);
+        // ── Orphan port detection ─────────────────────────────────────────────────
+        const orphanPorts = this.detectOrphanPorts(sessions, processInfo, ports, slowTick);
+        return {
+            sessions: sessions.map(normalizeSession),
+            rateLimits,
+            orphanPorts,
+            collectedAt: Date.now(),
+        };
+    }
+    detectOrphanPorts(sessions, processInfo, ports, slowTick) {
+        if (!slowTick)
+            return [...this.flattenOrphans()];
+        const sessionPids = new Set(sessions.map((s) => s.pid));
+        const sessionChildPids = new Set();
+        for (const s of sessions) {
+            for (const c of s.children)
+                sessionChildPids.add(c.pid);
+        }
+        // Any port-holding PID that is NOT under a live session → orphan candidate
+        for (const [pid, pidPorts] of ports) {
+            if (sessionPids.has(pid) || sessionChildPids.has(pid)) {
+                // Still alive under a session — remove from orphan map if present
+                this.orphanPortMap.delete(pid);
+                continue;
+            }
+            // Port-holding PID with no parent session
+            const proc = processInfo.get(pid);
+            if (!proc) {
+                this.orphanPortMap.delete(pid);
+                continue;
+            }
+            this.orphanPortMap.set(pid, pidPorts.map((port) => ({
+                port,
+                command: proc.command,
+                projectName: '?',
+            })));
+        }
+        // Remove orphan entries whose PID has died
+        for (const pid of this.orphanPortMap.keys()) {
+            if (!processInfo.has(pid))
+                this.orphanPortMap.delete(pid);
+        }
+        return [...this.flattenOrphans()];
+    }
+    flattenOrphans() {
+        const result = [];
+        for (const [pid, entries] of this.orphanPortMap) {
+            for (const e of entries) {
+                result.push({ pid, port: e.port, command: e.command, projectName: e.projectName });
+            }
+        }
+        return result;
+    }
+}
+exports.MultiCollector = MultiCollector;
+// ─── Snapshot normalization ───────────────────────────────────────────────────
+const VALID_STATUSES = new Set([
+    'thinking',
+    'executing',
+    'waiting',
+    'rateLimited',
+    'done',
+]);
+function num(n) {
+    return typeof n === 'number' && Number.isFinite(n) ? n : 0;
+}
+function str(s) {
+    return typeof s === 'string' ? s : '';
+}
+function arr(a) {
+    return Array.isArray(a) ? a : [];
+}
+/**
+ * Single source of truth for the snapshot wire shape. Every `AgentSession` that
+ * leaves `tick()` is run through this so:
+ *
+ *   • numeric fields are real numbers (never null / undefined / NaN);
+ *   • array fields are arrays (never null / undefined);
+ *   • status is a known `SessionStatus` (any unrecognized value defaults to
+ *     'waiting' — keeps the front end's filter sets honest);
+ *   • free-text fields that originate from agent-controlled content
+ *     (`currentTasks`, `initialPrompt`, `firstAssistantText`, `toolCalls[].arg`,
+ *     `fileAccesses[].path`) are run through `redactSecrets()` so a pasted
+ *     `sk-ant-…` doesn't end up rendered in the dashboard.
+ *
+ * Front-end null-coalescing guards (e.g. `value ?? 0`) become defence-in-depth
+ * after this runs server-side.
+ */
+function normalizeSession(s) {
+    const status = VALID_STATUSES.has(s.status) ? s.status : 'waiting';
+    return {
+        agentCli: str(s.agentCli),
+        pid: num(s.pid),
+        sessionId: str(s.sessionId),
+        cwd: str(s.cwd),
+        projectName: str(s.projectName),
+        startedAt: num(s.startedAt),
+        status,
+        model: str(s.model),
+        effort: str(s.effort),
+        contextPercent: num(s.contextPercent),
+        totalInputTokens: num(s.totalInputTokens),
+        totalOutputTokens: num(s.totalOutputTokens),
+        totalCacheRead: num(s.totalCacheRead),
+        totalCacheCreate: num(s.totalCacheCreate),
+        turnCount: num(s.turnCount),
+        currentTasks: arr(s.currentTasks).map((t) => (0, secrets_1.redactSecrets)(str(t))),
+        memMb: num(s.memMb),
+        version: str(s.version),
+        gitBranch: str(s.gitBranch),
+        gitAdded: num(s.gitAdded),
+        gitModified: num(s.gitModified),
+        tokenHistory: arr(s.tokenHistory).map(num),
+        contextHistory: arr(s.contextHistory).map(num),
+        compactionCount: num(s.compactionCount),
+        contextWindow: num(s.contextWindow) || 200000,
+        subagents: arr(s.subagents).map((sa) => ({
+            name: str(sa?.name),
+            status: sa?.status === 'done' ? 'done' : 'working',
+            tokens: num(sa?.tokens),
+        })),
+        memFileCount: num(s.memFileCount),
+        memLineCount: num(s.memLineCount),
+        children: arr(s.children).map((c) => ({
+            pid: num(c?.pid),
+            command: str(c?.command),
+            memKb: num(c?.memKb),
+            port: typeof c?.port === 'number' ? c.port : undefined,
+        })),
+        initialPrompt: (0, secrets_1.redactSecrets)(str(s.initialPrompt)),
+        firstAssistantText: (0, secrets_1.redactSecrets)(str(s.firstAssistantText)),
+        toolCalls: arr(s.toolCalls).map((tc) => ({
+            name: str(tc?.name),
+            arg: (0, secrets_1.redactSecrets)(str(tc?.arg)),
+            durationMs: num(tc?.durationMs),
+        })),
+        pendingSinceMs: num(s.pendingSinceMs),
+        thinkingSinceMs: num(s.thinkingSinceMs),
+        fileAccesses: arr(s.fileAccesses).map((fa) => ({
+            path: (0, secrets_1.redactSecrets)(str(fa?.path)),
+            operation: fa?.operation === 'Write' || fa?.operation === 'Edit' ? fa.operation : 'Read',
+            turnIndex: num(fa?.turnIndex),
+        })),
+    };
+}