@way_marks/server 4.0.2 → 4.3.0

package/dist/collectors/process.js

@@ -0,0 +1,257 @@
+"use strict";
+/**
+ * Process-tree and system data collector.
+ *
+ * Mirrors abtop/src/collector/process.rs:
+ *   - getProcessInfo()      → ps -eo pid,ppid,rss,%cpu,command
+ *   - getChildrenMap()      → adjacency map from ppid
+ *   - getListeningPorts()   → lsof -i -P -n -sTCP:LISTEN
+ *   - collectGitStats()     → git -C <cwd> status --porcelain
+ *   - hasActiveDescendant() → recursive CPU check
+ */
+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.getProcessInfo = getProcessInfo;
+exports.getChildrenMap = getChildrenMap;
+exports.hasActiveDescendant = hasActiveDescendant;
+exports.cmdHasBinary = cmdHasBinary;
+exports.getListeningPorts = getListeningPorts;
+exports.collectGitStats = collectGitStats;
+exports.mapPidsToOpenPaths = mapPidsToOpenPaths;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+// ─── Process info ────────────────────────────────────────────────────────────
+/**
+ * Run `ps` and return a map of pid → ProcInfo.
+ * Works on macOS and Linux (ps -eo is POSIX).
+ */
+function getProcessInfo() {
+    const map = new Map();
+    let stdout;
+    try {
+        // -ww: unlimited command width  -eo: exact output columns
+        stdout = (0, child_process_1.execSync)('ps -ww -eo pid,ppid,rss,%cpu,command', {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return map;
+    }
+    const lines = stdout.split('\n').slice(1); // skip header
+    for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 5)
+            continue;
+        const pid = parseInt(parts[0], 10);
+        const ppid = parseInt(parts[1], 10);
+        const rssKb = parseInt(parts[2], 10);
+        const cpuPct = parseFloat(parts[3]);
+        const command = parts.slice(4).join(' ');
+        if (isNaN(pid) || isNaN(ppid))
+            continue;
+        map.set(pid, { pid, ppid, rssKb: rssKb || 0, cpuPct: cpuPct || 0, command });
+    }
+    return map;
+}
+/**
+ * Build a parent-PID → child-PIDs map from the full process table.
+ */
+function getChildrenMap(procs) {
+    const children = new Map();
+    for (const proc of procs.values()) {
+        const list = children.get(proc.ppid) ?? [];
+        list.push(proc.pid);
+        children.set(proc.ppid, list);
+    }
+    return children;
+}
+/**
+ * Return true if any descendant of `pid` has CPU% above `cpuThreshold`.
+ * Mirrors abtop's `has_active_descendant`.
+ */
+function hasActiveDescendant(pid, childrenMap, processInfo, cpuThreshold = 5.0) {
+    const stack = [pid];
+    const visited = new Set();
+    while (stack.length > 0) {
+        const p = stack.pop();
+        if (visited.has(p))
+            continue;
+        visited.add(p);
+        const kids = childrenMap.get(p) ?? [];
+        for (const kid of kids) {
+            const info = processInfo.get(kid);
+            if (info && info.cpuPct > cpuThreshold)
+                return true;
+            stack.push(kid);
+        }
+    }
+    return false;
+}
+/**
+ * Check whether a command string contains a given binary name in executable
+ * position (first or second token — covers `node /path/to/codex ...`).
+ * Mirrors abtop's `cmd_has_binary`.
+ */
+function cmdHasBinary(cmd, name) {
+    const tokens = cmd.trim().split(/\s+/).slice(0, 2);
+    return tokens.some((tok) => {
+        const base = tok.split('/').pop() ?? tok;
+        return base === name;
+    });
+}
+// ─── Listening ports ──────────────────────────────────────────────────────────
+/**
+ * Return a map of pid → port[] by parsing `lsof -i -P -n -sTCP:LISTEN`.
+ * Mirrors abtop's `get_listening_ports` (non-Linux path).
+ */
+function getListeningPorts() {
+    const map = new Map();
+    let stdout;
+    try {
+        stdout = (0, child_process_1.execSync)('lsof -i -P -n -sTCP:LISTEN', {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return map;
+    }
+    for (const line of stdout.split('\n').slice(1)) {
+        const parts = line.trim().split(/\s+/);
+        // COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME (LISTEN)
+        if (parts.length < 9)
+            continue;
+        if (parts[7] !== 'TCP')
+            continue;
+        if (!line.includes('(LISTEN)'))
+            continue;
+        const pid = parseInt(parts[1], 10);
+        if (isNaN(pid))
+            continue;
+        // NAME field: *:3000 or 127.0.0.1:3000
+        const addr = parts[8] ?? '';
+        const portStr = addr.split(':').pop();
+        if (!portStr)
+            continue;
+        const port = parseInt(portStr, 10);
+        if (isNaN(port))
+            continue;
+        const ports = map.get(pid) ?? [];
+        if (!ports.includes(port))
+            ports.push(port);
+        map.set(pid, ports);
+    }
+    return map;
+}
+// ─── Git status ───────────────────────────────────────────────────────────────
+/**
+ * Run `git -C <cwd> status --porcelain` and return [added, modified] counts.
+ * Mirrors abtop's `collect_git_stats`.
+ */
+function collectGitStats(cwd) {
+    // Validate cwd is an absolute path before using as a working directory
+    if (!cwd || !path.isAbsolute(cwd))
+        return { added: 0, modified: 0 };
+    let stdout;
+    try {
+        stdout = (0, child_process_1.execFileSync)('git', ['status', '--porcelain'], {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return { added: 0, modified: 0 };
+    }
+    let added = 0;
+    let modified = 0;
+    for (const line of stdout.split('\n')) {
+        if (line.length < 2)
+            continue;
+        const code = line.slice(0, 2);
+        if (code.includes('?') || code.includes('A'))
+            added++;
+        else if (code.includes('M'))
+            modified++;
+    }
+    return { added, modified };
+}
+// ─── Open file paths via lsof ─────────────────────────────────────────────────
+/**
+ * Map each PID to the list of file paths it has open.
+ * Uses `lsof -F ftn -p<pid1> -p<pid2> ...` (field output).
+ * Mirrors abtop's `map_pid_to_lsof_open_paths`.
+ */
+function mapPidsToOpenPaths(pids) {
+    const map = new Map();
+    if (pids.length === 0)
+        return map;
+    // Build args array: per-PID filters use separate -p flags
+    const lsofArgs = ['-F', 'ftn', ...pids.map((p) => `-p${p}`)];
+    let stdout;
+    try {
+        stdout = (0, child_process_1.execFileSync)('lsof', lsofArgs, {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+    }
+    catch {
+        return map;
+    }
+    let currentPid = null;
+    let currentFd = '';
+    for (const line of stdout.split('\n')) {
+        if (line.startsWith('p')) {
+            currentPid = parseInt(line.slice(1), 10) || null;
+            if (currentPid != null && !map.has(currentPid))
+                map.set(currentPid, []);
+            currentFd = '';
+        }
+        else if (line.startsWith('f')) {
+            currentFd = line.slice(1);
+        }
+        else if (line.startsWith('n') && currentPid != null) {
+            const name = line.slice(1);
+            if (!name || name.startsWith('['))
+                continue;
+            const paths = map.get(currentPid) ?? [];
+            paths.push(name);
+            if (!map.has(currentPid))
+                map.set(currentPid, paths);
+        }
+    }
+    return map;
+}

package/dist/collectors/rate-limit.js

@@ -0,0 +1,161 @@
+"use strict";
+/**
+ * Rate limit file reader for Claude Code.
+ *
+ * Mirrors abtop/src/collector/rate_limit.rs.
+ *
+ * Claude Code rate limits are NOT in the transcript JSONL. They are written
+ * by the StatusLine hook installed via `abtop --setup` (or `waymark --setup`).
+ *
+ * File: ~/.claude/abtop-rate-limits.json
+ * Format:
+ *   {
+ *     "source": "claude",
+ *     "five_hour":  { "used_percentage": 35.0, "resets_at": 1774715000 },
+ *     "seven_day":  { "used_percentage": 12.0, "resets_at": 1775320000 },
+ *     "updated_at": 1774714400
+ *   }
+ */
+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.readClaudeRateLimits = readClaudeRateLimits;
+exports.readCodexRateLimitCache = readCodexRateLimitCache;
+exports.writeCodexRateLimitCache = writeCodexRateLimitCache;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const RATE_FILE_NAME = 'abtop-rate-limits.json';
+/** Reject stale Claude rate limit data older than 10 minutes. */
+const MAX_STALENESS_SECS = 600;
+/**
+ * Read Claude rate limit info from all candidate config directories.
+ * Checks `~/.claude`, `CLAUDE_CONFIG_DIR` env var, and any extra dirs
+ * provided (e.g. discovered from running Claude process environments).
+ *
+ * Returns all valid, non-stale entries (typically zero or one).
+ */
+function readClaudeRateLimits(extraDirs = []) {
+    const results = [];
+    const seen = new Set();
+    const candidates = [path.join(os.homedir(), '.claude')];
+    const envDir = process.env['CLAUDE_CONFIG_DIR'];
+    if (envDir)
+        candidates.push(envDir);
+    candidates.push(...extraDirs);
+    for (const dir of candidates) {
+        const resolved = path.resolve(dir);
+        if (seen.has(resolved))
+            continue;
+        seen.add(resolved);
+        if (!fs.existsSync(resolved))
+            continue;
+        const filePath = path.join(resolved, RATE_FILE_NAME);
+        const info = readRateFile(filePath, 'claude');
+        if (info)
+            results.push(info);
+    }
+    return results;
+}
+/**
+ * Read Codex rate limit from the shared cache file written by the collector.
+ * File: ~/.cache/abtop/codex-rate-limits.json
+ */
+function readCodexRateLimitCache() {
+    const cacheDir = process.env['XDG_CACHE_HOME'] ?? path.join(os.homedir(), '.cache');
+    const filePath = path.join(cacheDir, 'abtop', 'codex-rate-limits.json');
+    return readRateFile(filePath, 'codex', /* checkStaleness */ false);
+}
+/**
+ * Atomically write Codex rate limit to the shared cache file.
+ * Mirrors abtop's `write_codex_cache`.
+ */
+function writeCodexRateLimitCache(info) {
+    const cacheDir = process.env['XDG_CACHE_HOME'] ?? path.join(os.homedir(), '.cache');
+    const dir = path.join(cacheDir, 'abtop');
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, 'codex-rate-limits.json');
+    const tmp = filePath + '.tmp';
+    const json = JSON.stringify({
+        source: 'codex',
+        five_hour: info.fiveHourPct != null
+            ? { used_percentage: info.fiveHourPct, resets_at: info.fiveHourResetsAt ?? 0 }
+            : null,
+        seven_day: info.sevenDayPct != null
+            ? { used_percentage: info.sevenDayPct, resets_at: info.sevenDayResetsAt ?? 0 }
+            : null,
+        updated_at: info.updatedAt ?? null,
+    });
+    try {
+        fs.writeFileSync(tmp, json);
+        fs.renameSync(tmp, filePath);
+    }
+    catch {
+        // Best-effort; ignore write failures
+    }
+}
+// ─── Internal helpers ─────────────────────────────────────────────────────────
+function readRateFile(filePath, defaultSource, checkStaleness = true) {
+    let content;
+    try {
+        content = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let file;
+    try {
+        file = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    // Must have at least one window
+    if (!file.five_hour && !file.seven_day)
+        return null;
+    // Reject stale Claude data
+    if (checkStaleness && file.updated_at != null) {
+        const nowSecs = Math.floor(Date.now() / 1000);
+        if (nowSecs - file.updated_at > MAX_STALENESS_SECS)
+            return null;
+    }
+    return {
+        source: file.source || defaultSource,
+        fiveHourPct: file.five_hour?.used_percentage,
+        fiveHourResetsAt: file.five_hour?.resets_at,
+        sevenDayPct: file.seven_day?.used_percentage,
+        sevenDayResetsAt: file.seven_day?.resets_at,
+        updatedAt: file.updated_at,
+    };
+}

package/dist/collectors/secrets.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Secret pattern redaction utility.
+ *
+ * Mirrors abtop/src/collector/mod.rs `redact_secrets`.
+ * Best-effort: covers well-known prefixed tokens, not arbitrary high-entropy strings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactSecrets = redactSecrets;
+const SECRET_PATTERNS = [
+    // Anthropic / OpenAI / OpenRouter
+    'sk-ant-', 'sk-proj-', 'sk-or-',
+    // Stripe
+    'sk_live_', 'sk_test_', 'rk_live_', 'rk_test_',
+    // GitHub
+    'ghp_', 'gho_', 'ghs_', 'ghr_', 'ghu_', 'github_pat_',
+    // GitLab
+    'glpat-',
+    // Slack
+    'xoxb-', 'xoxp-', 'xoxa-', 'xoxs-',
+    // AWS access key ids
+    'AKIA', 'ASIA',
+    // Bearer-prefixed headers
+    'Bearer ',
+];
+/**
+ * Replace known secret prefixes and following non-whitespace chars with [REDACTED].
+ */
+function redactSecrets(s) {
+    let result = s;
+    for (const pat of SECRET_PATTERNS) {
+        let pos = result.indexOf(pat);
+        while (pos !== -1) {
+            // Find end: next whitespace or end of string
+            let end = pos + pat.length;
+            while (end < result.length && !/\s/.test(result.charAt(end)))
+                end++;
+            result = result.slice(0, pos) + '[REDACTED]' + result.slice(end);
+            pos = result.indexOf(pat, pos + '[REDACTED]'.length);
+        }
+    }
+    return result;
+}

package/dist/collectors/types.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Shared TypeScript types for the abtop-style agent monitor feature.
+ * These mirror the Rust structs in abtop/src/model/session.rs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTEXT_WINDOW_BY_MODEL = exports.MAX_FILE_ACCESSES = void 0;
+exports.contextWindowForModel = contextWindowForModel;
+exports.elapsedDisplay = elapsedDisplay;
+/** Maximum file access entries kept per session. */
+exports.MAX_FILE_ACCESSES = 1000;
+/** Context window sizes by model name. */
+exports.CONTEXT_WINDOW_BY_MODEL = {
+    'claude-opus-4-6': 200000,
+    'claude-opus-4-6[1m]': 1000000,
+    'claude-sonnet-4-6': 200000,
+    'claude-haiku-4-5': 200000,
+    'claude-opus-4-5': 200000,
+    'claude-sonnet-4-5': 200000,
+    'claude-haiku-4': 200000,
+    'claude-opus-4': 200000,
+    'claude-sonnet-4': 200000,
+    // GitHub Copilot CLI supported models
+    'gpt-5': 128000,
+    'gpt-5-mini': 128000,
+    'o3': 200000,
+    'o4-mini': 200000,
+};
+/** Derive context window size from model name, falling back to 200k. */
+function contextWindowForModel(model, maxSeen = 0) {
+    const known = exports.CONTEXT_WINDOW_BY_MODEL[model];
+    if (known)
+        return known;
+    // If we observed a turn with context > 200k, it must be a 1M model.
+    if (maxSeen > 200000)
+        return 1000000;
+    return 200000;
+}
+/** Elapsed time as a short human-readable string ("12s", "5m", "2h 10m"). */
+function elapsedDisplay(startedAtMs) {
+    const secs = Math.floor((Date.now() - startedAtMs) / 1000);
+    if (secs < 60)
+        return `${secs}s`;
+    if (secs < 3600)
+        return `${Math.floor(secs / 60)}m`;
+    return `${Math.floor(secs / 3600)}h ${Math.floor((secs % 3600) / 60)}m`;
+}

package/dist/mcp/server.js

@@ -57,7 +57,15 @@ const uuid_1 = require("uuid");
 const database_1 = require("../db/database");
 const engine_1 = require("../policies/engine");
 const slack_1 = require("../notifications/slack");
+const agent_monitor_1 = require("./tools/agent-monitor");
 const SESSION_ID = (0, uuid_1.v4)();
+// Agent monitor — fetch from the sibling API process on demand instead of
+// running a second MultiCollector here. WAYMARK_PORT is set by `waymark start`
+// when it spawns this MCP child; if absent we default to the v3.1+ default
+// range start. fetchSnapshotFromApi() returns an empty snapshot when the API
+// is unreachable, so the MCP tool calls degrade gracefully.
+const API_PORT = parseInt(process.env.WAYMARK_PORT || '47000', 10);
+const getAgentSnapshot = () => (0, agent_monitor_1.fetchSnapshotFromApi)(API_PORT);
 // Build PATH that includes the current node binary's directory.
 // process.execPath works regardless of version manager (nvm, Homebrew, system, etc.)
 function getUserPath() {
@@ -114,12 +122,18 @@ server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
                     required: ['command'],
                 },
             },
+            ...agent_monitor_1.AGENT_MONITOR_TOOL_DEFINITIONS,
         ],
     };
 });
 // Handle tool calls
 server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    // Agent monitor tools — read-only, no logging needed.
+    // Snapshot is fetched from the sibling API process; empty if API unreachable.
+    const monitorResult = await (0, agent_monitor_1.handleAgentMonitorToolCall)(name, args, getAgentSnapshot);
+    if (monitorResult)
+        return monitorResult;
     const action_id = (0, uuid_1.v4)();
     const input_payload = JSON.stringify(args);
     if (name === 'write_file') {