@agent-beam/beam 0.2.23 → 0.2.24

package/dist/monitor-rules.js

@@ -0,0 +1,108 @@
+// Detection rules for `beam monitor`: attacks against a running application, seen in its logs and
+// HTTP access logs. Separate from the agent-hook catalog in core.ts on purpose -- application logs
+// are full of words like "env", "token" and "production" that would drown those rules -- but a few
+// built-in rules that mean the same thing anywhere (reverse shells, piped remote code, cloud
+// metadata access, prompt injection) are reused as-is. Heuristic, like everything else in Beam.
+import { builtinRulesById } from "./core.js";
+// Trailing boundary for shell commands, so `| id=5` in a log line isn't read as running `id`.
+const END = String.raw `(?=$|[\s;'"&|)\x60])`;
+const commandInjection = new RegExp(String.raw `(?:[;|\x60]|\$\(|&&)\s*(?:id|whoami|uname\s+-a|cat\s+/etc/(?:passwd|shadow)|(?:curl|wget)\s+\S+|nc\s+-\w|bash\s+-[ic]|sh\s+-c|ping\s+-c\s*\d+)${END}`, "i");
+const appRules = [
+    { id: "web.jndi_injection", title: "JNDI lookup (Log4Shell-style) injection", severity: "critical", category: "exploit",
+        match: s => /\$\{\s*jndi\s*:|\$\{\s*\$\{\s*(?:::-|lower:|upper:|env:)/i.test(s) },
+    { id: "web.path_traversal", title: "Path traversal attempt", severity: "high", category: "exploit",
+        match: s => /(?:\.\.[/\\]){2,}|\/etc\/(?:passwd|shadow)\b|\bwin\.ini\b|\/proc\/self\/(?:environ|cmdline)/i.test(s) },
+    { id: "web.sql_injection", title: "SQL injection attempt", severity: "high", category: "exploit",
+        match: s => /\bunion\b[\s(]+(?:all\s+)?select\b|'\s*(?:or|and)\s+'?\d+'?\s*=\s*'?\d+|\b(?:or|and)\s+1\s*=\s*1\b|\b(?:sleep|pg_sleep)\s*\(\s*\d+\s*\)|\bbenchmark\s*\(\s*\d+|\bwaitfor\s+delay\s+'|\binformation_schema\b|\bxp_cmdshell\b/i.test(s) },
+    { id: "web.command_injection", title: "Command injection attempt", severity: "high", category: "exploit",
+        match: s => commandInjection.test(s) },
+    { id: "web.template_injection", title: "Server-side template injection probe", severity: "high", category: "exploit",
+        match: s => /\{\{\s*\d+\s*\*\s*\d+\s*\}\}|\$\{\s*\d+\s*\*\s*\d+\s*\}|<%=?\s*\d+\s*\*\s*\d+\s*%>|__class__\.__mro__|__globals__\[|\{\{\s*(?:config|self|request)\.[a-z_]/i.test(s) },
+    { id: "web.webshell", title: "Web shell access", severity: "high", category: "persistence",
+        match: s => /\/(?:c99|r57|wso|b374k|webshell|cmd|shell)\.(?:php|jsp|aspx?)\b|[?&](?:cmd|exec|command)=(?:whoami|id|ls|uname|cat)\b/i.test(s) },
+    { id: "web.deserialization", title: "Serialized object payload", severity: "high", category: "exploit",
+        match: s => /\brO0AB[A-Za-z0-9+/=]{8,}|\bO:\d+:"[A-Za-z_\\]+":\d+:\{/.test(s) },
+    { id: "app.secret_in_log", title: "Credential written to logs", severity: "high", category: "secrets",
+        match: (_s, raw) => /-----BEGIN [A-Z ]*PRIVATE KEY-----|\b(?:sk-(?:proj-|ant-)?[A-Za-z0-9_-]{20,}|gh[pousr]_[A-Za-z0-9_]{30,}|github_pat_[A-Za-z0-9_]{20,}|AKIA[A-Z0-9]{16}|xox[baprs]-[\w-]{10,}|AIza[0-9A-Za-z_-]{35})\b|\bauthorization:\s*bearer\s+[A-Za-z0-9._~+/-]{20,}/i.test(raw) },
+    { id: "web.xss", title: "Cross-site scripting attempt", severity: "medium", category: "exploit",
+        match: s => /<script[\s>]|javascript:\s*[a-z(]|<(?:img|svg|body|iframe)\b[^>]{0,200}\son(?:error|load)\s*=|\bdocument\.cookie\b/i.test(s) },
+    { id: "web.prototype_pollution", title: "Prototype pollution attempt", severity: "medium", category: "exploit",
+        match: s => /\b__proto__\b\s*[\]["'=:.]|constructor\s*\[\s*["']?prototype/i.test(s) },
+    { id: "web.sensitive_file_probe", title: "Probe for secrets or config files", severity: "medium", category: "recon", sources: ["http"],
+        match: s => /\/(?:\.env(?:\.[\w-]+)?|\.git\/(?:config|HEAD)|\.aws\/credentials|\.ssh\/id_\w+|wp-config\.php(?:\.bak)?|\.htpasswd|server-status|actuator\/(?:env|heapdump)|\.DS_Store)(?=[\s?"'#]|$)/i.test(s) },
+    { id: "web.scanner", title: "Known attack tool", severity: "medium", category: "recon", sources: ["http"],
+        match: s => /\b(?:sqlmap|nikto|nuclei|masscan|zgrab|acunetix|nessus|wpscan|dirbuster|gobuster|feroxbuster|ffuf|hydra|openvas|commix|xsstrike)\b/i.test(s) },
+];
+const sharedRules = builtinRulesById(["network.reverse-shell", "execution.remote", "execution.obfuscated", "network.metadata", "instructions.override"])
+    .map(r => ({ id: r.id, title: r.title, severity: r.severity === "info" ? "medium" : r.severity, category: r.category, match: (s) => r.match(s) }));
+export const monitorRules = [...appRules, ...sharedRules];
+const HTTP_LINE = /"(?:GET|POST|PUT|DELETE|PATCH|HEAD|OPTIONS|CONNECT|TRACE) \S+ HTTP\/[\d.]+"|^\S+ \S+ \S+ \[[^\]]+\] "|"(?:method|http_method|request_method)"\s*:\s*"[A-Z]+"/;
+export function lineSource(line) {
+    return HTTP_LINE.test(line) ? "http" : "log";
+}
+function percentDecode(s) {
+    try {
+        return decodeURIComponent(s);
+    }
+    catch {
+        return s.replace(/%[0-9a-f]{2}/gi, m => String.fromCharCode(parseInt(m.slice(1), 16)));
+    }
+}
+/** URL-decodes up to twice so `%252e%252e%252f` (double-encoded `../`) is matched too. */
+export function decodeForMatch(line) {
+    let s = line.length > 16_384 ? line.slice(0, 16_384) : line;
+    for (let i = 0; i < 2; i++) {
+        const next = percentDecode(s.replace(/\+/g, " "));
+        if (next === s)
+            break;
+        s = next;
+    }
+    return s;
+}
+export function matchLine(line, source = lineSource(line)) {
+    const decoded = decodeForMatch(line);
+    const raw = line.length > 16_384 ? line.slice(0, 16_384) : line;
+    return monitorRules.filter(r => (!r.sources || r.sources.includes(source)) && r.match(decoded, raw));
+}
+/**
+ * Redaction for evidence that leaves the machine. Unlike the agent-hook redaction it keeps query
+ * strings -- for an access log the query usually *is* the attack -- but removes credentials,
+ * bearer tokens, URL userinfo, email addresses and the policy's custom detector matches.
+ */
+export function redactLine(line, custom = []) {
+    let out = line.slice(0, 4000)
+        .replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?(?:-----END [^-]*PRIVATE KEY-----|$)/g, "[REDACTED PRIVATE KEY]")
+        .replace(/\b(?:sk-(?:proj-|ant-)?[A-Za-z0-9_-]{12,}|gh[pousr]_[A-Za-z0-9_]{16,}|github_pat_[A-Za-z0-9_]{16,}|AKIA[A-Z0-9]{16}|xox[baprs]-[\w-]{10,}|AIza[0-9A-Za-z_-]{35})\b/g, "[REDACTED TOKEN]")
+        .replace(/(bearer\s+)[A-Za-z0-9._~+/-]{8,}/gi, "$1[REDACTED]")
+        .replace(/(\b(?:[\w-]*(?:api[_-]?key|token|secret|password|passwd|pwd|authorization|session|cookie)[\w-]*)["']?\s*[:=]\s*)["']?[^\s,"';&}\]]+/gi, "$1[REDACTED]")
+        .replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/gi, "$1[REDACTED]@")
+        .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, "[EMAIL]");
+    for (const detector of custom) {
+        try {
+            out = out.replace(new RegExp(detector.pattern, "g"), detector.replacement);
+        }
+        catch { /* reported by policy validation */ }
+    }
+    return out.slice(0, 600);
+}
+// JSON access logs (Railway, Vercel, Caddy, ALB/CloudFront exports, app loggers) name the client field.
+const JSON_CLIENT_IP = /"(?:srcIp|src_ip|clientIp|client_ip|remoteAddr|remote_addr|remoteIp|remote_ip|ip|client|x_forwarded_for|xForwardedFor|http_x_forwarded_for)"\s*:\s*"\[?([0-9a-fA-F:.]{3,45})/;
+const LEADING_IP = /^\[?((?:\d{1,3}\.){3}\d{1,3}|[0-9a-fA-F]*:[0-9a-fA-F:]+)\]?\s/;
+// Not preceded by a word character, "/" or "." so version strings like "Chrome/120.0.0.0" aren't read as addresses.
+const BARE_IPV4 = /(?<![\w/.])(?:\d{1,3}\.){3}\d{1,3}(?![\w.])/;
+/**
+ * The client address in an access-log line: a named field in JSON logs, the first token in
+ * nginx/Apache/Caddy common log format, otherwise the first standalone IPv4 address.
+ */
+export function clientIp(line) {
+    return line.match(JSON_CLIENT_IP)?.[1] ?? line.match(LEADING_IP)?.[1] ?? line.match(BARE_IPV4)?.[0];
+}
+const AUTH_PATH = /\/(?:login|signin|sign-in|auth|oauth|token|session|api\/v\d+\/auth|wp-login\.php|admin)\b/i;
+const AUTH_FAIL_TEXT = /\b(?:login|authentication|auth|sign[- ]?in)\s+(?:failed|failure|denied)|\binvalid\s+(?:password|credentials|username or password|api key|token)|\bfailed\s+password\b|\bincorrect\s+password\b|\bunauthori[sz]ed\b/i;
+/** A failed sign-in: a 401/403 on an auth path in an access log, or an app's own "login failed" line. */
+export function isAuthFailure(line, source) {
+    if (source === "http")
+        return (/"\s(?:401|403)\s/.test(line) || /"(?:status|httpStatus|status_code|statusCode|response_status)"\s*:\s*"?(?:401|403)\b/.test(line)) && AUTH_PATH.test(line);
+    return AUTH_FAIL_TEXT.test(line);
+}
+//# sourceMappingURL=monitor-rules.js.map

package/dist/monitor-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"monitor-rules.js","sourceRoot":"","sources":["../src/monitor-rules.ts"],"names":[],"mappings":"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"}

package/dist/monitor.d.ts

@@ -0,0 +1,72 @@
+import { type MonitorFinding, type MonitorLevel, type MonitorSeverity, type Vulnerability } from "./monitor-client.js";
+import type { CustomDetector } from "./data-detectors.js";
+/** light: critical only · standard: high and up · strict: medium and up (same thresholds as the server). */
+export declare const meetsLevel: (severity: MonitorSeverity, level: MonitorLevel) => boolean;
+export declare const DEDUPE_WINDOW_MS: Record<MonitorLevel, number>;
+export declare const BRUTE_FORCE_THRESHOLD: Record<MonitorLevel, number>;
+export declare const MAX_NEW_FINDINGS_PER_10_MIN = 200;
+export type SendOutcome = "sent" | "retry" | "drop";
+export interface PipelineOptions {
+    /** The active level, or null while capture is off (not enabled, or the allowance is spent). */
+    level: () => MonitorLevel | null;
+    customDetectors?: () => CustomDetector[];
+    now?: () => number;
+}
+export declare class MonitorPipeline {
+    private readonly opts;
+    private seen;
+    private queue;
+    private queued;
+    private authFailures;
+    private floodBucket;
+    private floodCount;
+    private suppressed;
+    constructor(opts: PipelineOptions);
+    private now;
+    get pending(): MonitorFinding[];
+    /** Matches one line and queues any findings at or above the level. Returns the rule ids raised. */
+    ingestLine(line: string, file?: string): string[];
+    /** Queues a finding produced elsewhere (dependency checks) under its own stable id, once. */
+    addFinding(finding: MonitorFinding): boolean;
+    private raise;
+    private emitSuppressed;
+    private enqueue;
+    /** Sends queued findings in batches; a "retry" outcome keeps the batch for the next flush. */
+    flush(send: (batch: MonitorFinding[]) => Promise<SendOutcome>): Promise<void>;
+}
+/** Follows a log file like `tail -F`: survives rotation (new inode) and truncation (copytruncate). */
+export declare class FileTailer {
+    private readonly path;
+    private readonly onLine;
+    private readonly fromStart;
+    private offset;
+    private ino;
+    private tracking;
+    private firstPoll;
+    private partial;
+    private decoder;
+    private signature;
+    private timer;
+    private busy;
+    constructor(path: string, onLine: (line: string) => void, fromStart?: boolean);
+    start(intervalMs?: number): void;
+    stop(): void;
+    private reset;
+    poll(): Promise<void>;
+    private signatureHolds;
+}
+/** A dependency vulnerability as a monitor finding. CISA KEV (exploited in the wild) is raised to critical. */
+export declare function vulnerabilityFinding(v: Vulnerability): MonitorFinding;
+export interface MonitorOptions {
+    files?: string[];
+    stdin?: boolean;
+    /** Pass stdin lines through to stdout so piping an app into beam doesn't swallow its output. */
+    echo?: boolean;
+    /** App directory whose lockfiles are checked for known vulnerabilities at start and daily. */
+    app?: string;
+    fromStart?: boolean;
+    /** Keep waiting while App monitoring is off in the dashboard (default) instead of exiting. */
+    wait?: boolean;
+}
+export declare function runMonitor(options: MonitorOptions, log?: (message: string) => void): Promise<void>;
+export declare function monitorStatus(write?: (line: string) => void): Promise<number>;

package/dist/monitor.js

@@ -0,0 +1,459 @@
+// `beam monitor`: 24x7 watch over a running application's logs and traffic. Lines are matched
+// against monitor-rules.ts on this machine; only redacted, deduplicated findings are sent to the
+// workspace, which stores them, meters them and delivers them to the workspace's webhooks.
+//
+// It never blocks or alters the application: it reads log files (or a pipe it echoes straight
+// through) and does nothing else to the app. It is also inert until the workspace turns App
+// monitoring on in the dashboard -- before that, and whenever it is turned off again or the
+// monthly allowance runs out, lines are read and discarded.
+import { createHash } from "node:crypto";
+import { open } from "node:fs/promises";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { StringDecoder } from "node:string_decoder";
+import { readIdentity } from "./enroll.js";
+import { readPolicy } from "./policy.js";
+import { readInstalledPackages } from "./lockfiles.js";
+import { checkPackages, fetchMonitorConfig, sendFindings, } from "./monitor-client.js";
+import { clientIp, isAuthFailure, lineSource, matchLine, redactLine } from "./monitor-rules.js";
+import { judgeWithOwnLlm, ownLlmConfig } from "./monitor-llm.js";
+const RANK = { critical: 3, high: 2, medium: 1, low: 0 };
+const MIN_RANK = { light: 3, standard: 2, strict: 1 };
+/** light: critical only · standard: high and up · strict: medium and up (same thresholds as the server). */
+export const meetsLevel = (severity, level) => RANK[severity] >= MIN_RANK[level];
+// One finding absorbs repeats (its `count` goes up) for this long before a new one is raised.
+export const DEDUPE_WINDOW_MS = { light: 60 * 60_000, standard: 15 * 60_000, strict: 5 * 60_000 };
+// Failed sign-ins from one address within five minutes before it counts as brute forcing.
+export const BRUTE_FORCE_THRESHOLD = { light: 50, standard: 20, strict: 10 };
+const BRUTE_FORCE_WINDOW_MS = 5 * 60_000;
+// A scan or a log loop can match thousands of distinct lines; past this many new findings in ten
+// minutes the rest are folded into one summary finding so a flood can't spend the month's allowance.
+export const MAX_NEW_FINDINGS_PER_10_MIN = 200;
+const FLOOD_WINDOW_MS = 10 * 60_000;
+const MAX_QUEUE = 1000;
+const BATCH_SIZE = 100;
+/** Groups lines that differ only in ids, numbers, addresses or timestamps. */
+function normalizeForGrouping(line) {
+    return line.toLowerCase()
+        .replace(/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, "<ip>")
+        .replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/g, "<id>")
+        .replace(/\b[0-9a-f]{16,}\b/g, "<hex>")
+        .replace(/\d+/g, "0")
+        .replace(/\s+/g, " ")
+        .slice(0, 300);
+}
+export class MonitorPipeline {
+    opts;
+    seen = new Map();
+    queue = [];
+    queued = new Set();
+    authFailures = new Map();
+    floodBucket = -1;
+    floodCount = 0;
+    suppressed = null;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    now() { return this.opts.now?.() ?? Date.now(); }
+    get pending() { return [...this.queue]; }
+    /** Matches one line and queues any findings at or above the level. Returns the rule ids raised. */
+    ingestLine(line, file) {
+        const level = this.opts.level();
+        if (!level || !line.trim())
+            return [];
+        const custom = this.opts.customDetectors?.() ?? [];
+        const source = lineSource(line);
+        const ip = source === "http" ? clientIp(line) : undefined;
+        const raised = [];
+        for (const rule of matchLine(line, source)) {
+            if (!meetsLevel(rule.severity, level))
+                continue;
+            // Traffic groups by client address (one scan = one finding); app logs group by line shape.
+            this.raise(level, ip ?? normalizeForGrouping(line), {
+                ruleId: rule.id, title: ip ? `${rule.title} from ${ip}` : rule.title, severity: rule.severity,
+                category: rule.category, source, file, evidence: redactLine(line, custom),
+            });
+            raised.push(rule.id);
+        }
+        if (isAuthFailure(line, source) && meetsLevel("high", level)) {
+            const key = clientIp(line) ?? "unknown address";
+            const now = this.now();
+            const recent = (this.authFailures.get(key) ?? []).filter(t => now - t < BRUTE_FORCE_WINDOW_MS);
+            recent.push(now);
+            this.authFailures.set(key, recent);
+            if (this.authFailures.size > 10_000)
+                this.authFailures.delete(this.authFailures.keys().next().value);
+            if (recent.length >= BRUTE_FORCE_THRESHOLD[level]) {
+                this.raise(level, key, {
+                    ruleId: "app.auth_bruteforce", title: `Repeated failed sign-ins from ${key}`, severity: "high", category: "recon",
+                    source, file, evidence: `${recent.length} failures in 5 minutes. Latest: ${redactLine(line, custom)}`.slice(0, 600),
+                });
+                raised.push("app.auth_bruteforce");
+            }
+        }
+        return raised;
+    }
+    /** Queues a finding produced elsewhere (dependency checks) under its own stable id, once. */
+    addFinding(finding) {
+        const level = this.opts.level();
+        if (!level || !meetsLevel(finding.severity, level) || this.queued.has(finding.id))
+            return false;
+        this.queued.add(finding.id);
+        this.enqueue(finding);
+        return true;
+    }
+    raise(level, groupKey, partial) {
+        const now = this.now();
+        const bucket = Math.floor(now / DEDUPE_WINDOW_MS[level]);
+        const fp = createHash("sha256").update(`${partial.ruleId}\0${groupKey}`).digest("hex").slice(0, 24);
+        const existing = this.seen.get(fp);
+        if (existing && existing.bucket === bucket) {
+            existing.finding.count++; // still queued: the batch carries the new count
+            return;
+        }
+        const flood = Math.floor(now / FLOOD_WINDOW_MS);
+        if (flood !== this.floodBucket) {
+            this.emitSuppressed();
+            this.floodBucket = flood;
+            this.floodCount = 0;
+        }
+        if (this.floodCount >= MAX_NEW_FINDINGS_PER_10_MIN) {
+            const worst = this.suppressed && RANK[this.suppressed.severity] >= RANK[partial.severity] ? this.suppressed.severity : partial.severity;
+            this.suppressed = { count: (this.suppressed?.count ?? 0) + 1, severity: worst };
+            return;
+        }
+        this.floodCount++;
+        const finding = { id: `${fp}-${bucket}`, ...partial, count: 1, firstSeen: new Date(now).toISOString() };
+        this.seen.set(fp, { bucket, finding, at: now });
+        this.enqueue(finding);
+    }
+    emitSuppressed() {
+        if (!this.suppressed)
+            return;
+        const { count, severity } = this.suppressed;
+        this.suppressed = null;
+        this.enqueue({
+            id: `flood-${this.floodBucket}`, ruleId: "beam.monitor.flood", title: "Too many findings to send individually", severity,
+            category: "integrity", source: "log", count,
+            evidence: `${count} more findings within 10 minutes were not sent one by one, to protect the monthly allowance. Check this server's logs.`,
+            firstSeen: new Date(this.floodBucket * FLOOD_WINDOW_MS).toISOString(),
+        });
+    }
+    enqueue(finding) {
+        if (this.queue.length >= MAX_QUEUE) {
+            // Full (usually: the workspace is unreachable). Make room by dropping the least severe, oldest.
+            let drop = 0;
+            for (let i = 1; i < this.queue.length; i++)
+                if (RANK[this.queue[i].severity] < RANK[this.queue[drop].severity])
+                    drop = i;
+            this.queue.splice(drop, 1);
+        }
+        this.queue.push(finding);
+    }
+    /** Sends queued findings in batches; a "retry" outcome keeps the batch for the next flush. */
+    async flush(send) {
+        if (this.suppressed && Math.floor(this.now() / FLOOD_WINDOW_MS) !== this.floodBucket)
+            this.emitSuppressed();
+        while (this.queue.length) {
+            const batch = this.queue.splice(0, BATCH_SIZE);
+            if ((await send(batch)) === "retry") {
+                this.queue.unshift(...batch);
+                break;
+            }
+        }
+        const cutoff = this.now() - 2 * DEDUPE_WINDOW_MS.light;
+        for (const [fp, entry] of this.seen)
+            if (entry.at < cutoff)
+                this.seen.delete(fp);
+    }
+}
+/** Follows a log file like `tail -F`: survives rotation (new inode) and truncation (copytruncate). */
+export class FileTailer {
+    path;
+    onLine;
+    fromStart;
+    offset = 0;
+    ino = -1;
+    tracking = false;
+    firstPoll = true;
+    partial = "";
+    decoder = new StringDecoder("utf8");
+    // The last bytes read. If they're no longer at the same position, the file was truncated and
+    // rewritten past our offset between polls (copytruncate under load), which size alone can't show.
+    signature = Buffer.alloc(0);
+    timer;
+    busy = false;
+    constructor(path, onLine, fromStart = false) {
+        this.path = path;
+        this.onLine = onLine;
+        this.fromStart = fromStart;
+    }
+    start(intervalMs = 1000) {
+        void this.poll();
+        this.timer = setInterval(() => void this.poll(), intervalMs);
+    }
+    stop() { if (this.timer)
+        clearInterval(this.timer); }
+    reset(offset, ino) {
+        this.offset = offset;
+        this.ino = ino;
+        this.partial = "";
+        this.decoder = new StringDecoder("utf8");
+        this.signature = Buffer.alloc(0);
+    }
+    async poll() {
+        if (this.busy)
+            return;
+        this.busy = true;
+        let handle;
+        try {
+            try {
+                handle = await open(this.path, "r");
+            }
+            catch {
+                this.firstPoll = false;
+                return;
+            } // not there (yet): keep waiting
+            const info = await handle.stat();
+            if (!this.tracking) {
+                // Existing file at start: begin at the end, like tail. A file that appears later is read whole.
+                this.reset(this.firstPoll && !this.fromStart ? info.size : 0, info.ino);
+                this.tracking = true;
+                const keep = Math.min(SIGNATURE_BYTES, this.offset);
+                if (keep)
+                    this.signature = await readAt(handle, this.offset - keep, keep);
+            }
+            else if (info.ino !== this.ino || info.size < this.offset || !(await this.signatureHolds(handle))) {
+                this.reset(0, info.ino);
+            }
+            this.firstPoll = false;
+            while (info.size > this.offset) {
+                const chunk = await readAt(handle, this.offset, Math.min(info.size - this.offset, 4 * 1024 * 1024));
+                if (!chunk.length)
+                    break;
+                this.offset += chunk.length;
+                this.signature = Buffer.concat([this.signature, chunk.subarray(-SIGNATURE_BYTES)]).subarray(-SIGNATURE_BYTES);
+                const lines = (this.partial + this.decoder.write(chunk)).split(/\r?\n/);
+                this.partial = lines.pop() ?? "";
+                if (this.partial.length > 65_536) {
+                    lines.push(this.partial.slice(0, 65_536));
+                    this.partial = "";
+                }
+                for (const line of lines)
+                    this.onLine(line);
+            }
+        }
+        finally {
+            await handle?.close();
+            this.busy = false;
+        }
+    }
+    async signatureHolds(handle) {
+        if (!this.signature.length)
+            return true;
+        return (await readAt(handle, this.offset - this.signature.length, this.signature.length)).equals(this.signature);
+    }
+}
+const SIGNATURE_BYTES = 64;
+async function readAt(handle, position, length) {
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, position);
+    return buffer.subarray(0, bytesRead);
+}
+const SEVERITIES = ["critical", "high", "medium", "low"];
+/** A dependency vulnerability as a monitor finding. CISA KEV (exploited in the wild) is raised to critical. */
+export function vulnerabilityFinding(v) {
+    const severity = v.kev ? "critical" : SEVERITIES.includes(v.severity) ? v.severity : "medium";
+    const id = createHash("sha256").update(`${v.id}\0${v.ecosystem}\0${v.name}\0${v.version}`).digest("hex").slice(0, 24);
+    return {
+        id: `cve-${id}`, ruleId: v.id, title: `${v.id} in ${v.name} ${v.version}${v.kev ? " (actively exploited)" : ""}`, severity,
+        category: "cve", source: "cve", file: v.files[0], count: 1, firstSeen: new Date().toISOString(),
+        evidence: `${v.name} ${v.version} (${v.ecosystem}) is in the affected range ${v.vulnerable}; ${v.patched ? `fixed in ${v.patched}` : "no fixed version yet"}. ${v.title} ${v.url}`.slice(0, 600),
+    };
+}
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+export async function runMonitor(options, log = m => console.error(`[beam monitor] ${m}`)) {
+    const files = (options.files ?? []).map(f => resolve(f));
+    const appDir = options.app ? resolve(options.app) : undefined;
+    if (!files.length && !options.stdin && !appDir)
+        throw new Error("Tell beam monitor what to watch: --file <path> (repeatable) for log files, --stdin to read piped output, and/or --app <dir> for dependency checks.");
+    const identity = await readIdentity();
+    if (!identity)
+        throw new Error("Connect this server to your Beam workspace first: run 'beam connect'. App monitoring is then turned on for the workspace in the dashboard.");
+    const custom = (await readPolicy())?.rules.customDetectors ?? [];
+    const ownLlm = ownLlmConfig();
+    let config = null;
+    let lastRefresh = 0;
+    let pausedUntil = 0;
+    let offNotice = false;
+    let fatal = null;
+    const refresh = async () => {
+        lastRefresh = Date.now();
+        const result = await fetchMonitorConfig(identity);
+        if (result.ok) {
+            if (!config) {
+                log(`App monitoring is on (${result.config.level} level). Findings go to your workspace${result.config.webhooks ? ` and ${result.config.webhooks} webhook${result.config.webhooks === 1 ? "" : "s"}` : ""}.`);
+                log(ownLlm
+                    ? `LLM checks: your own model, ${ownLlm.model} at ${new URL(ownLlm.baseUrl).host}.`
+                    : `LLM checks: ${result.config.llm ? "Beam's model (set in the dashboard)" : "off"}.`);
+            }
+            else if (config.level !== result.config.level)
+                log(`Level changed to ${result.config.level}.`);
+            config = result.config;
+            offNotice = false;
+            return;
+        }
+        if (result.status === "disabled") {
+            if (!offNotice)
+                log(`${result.message}${options.wait === false ? "" : " Nothing is captured until then; checking again every minute."}`);
+            offNotice = true;
+            config = null;
+            return;
+        }
+        if (result.status === "revoked" || result.status === "unsupported")
+            throw new Error(result.message);
+        log(`${result.message} Retrying.`); // unreachable: keep the last known settings
+    };
+    await refresh();
+    while (!config) {
+        if (options.wait === false)
+            throw new Error("App monitoring is not on for this workspace.");
+        await sleep(60_000);
+        await refresh();
+    }
+    const pipeline = new MonitorPipeline({
+        level: () => (config && Date.now() >= pausedUntil ? config.level : null),
+        customDetectors: () => custom,
+    });
+    const send = async (batch) => {
+        if (ownLlm && config)
+            await judgeWithOwnLlm(batch, config.level, ownLlm);
+        const result = await sendFindings(identity, batch);
+        if (result.ok)
+            return "sent";
+        if (result.status === "disabled") {
+            log(`${result.message} Capture paused.`);
+            config = null;
+            offNotice = true;
+            return "drop";
+        }
+        if (result.status === "quota") {
+            pausedUntil = result.resetAt ? Date.parse(result.resetAt) : Date.now() + 60 * 60_000;
+            log(`${result.message} Capture paused until then.`);
+            return "drop";
+        }
+        if (result.status === "revoked" || result.status === "unsupported") {
+            fatal = new Error(result.message);
+            return "drop";
+        }
+        return "retry";
+    };
+    const checkDependencies = async () => {
+        if (!appDir || !config)
+            return;
+        const scan = await readInstalledPackages(appDir);
+        if (!scan.packages.length) {
+            log(`No pinned dependencies found under ${appDir}; skipping the dependency check.`);
+            return;
+        }
+        const result = await checkPackages(identity, scan.packages);
+        if (!result.ok) {
+            log(`Dependency check skipped: ${result.message}`);
+            return;
+        }
+        const { vulnerabilities, checked } = result.result;
+        log(`Dependency check: ${vulnerabilities.length} known vulnerabilit${vulnerabilities.length === 1 ? "y" : "ies"} in ${checked} packages under ${appDir}.`);
+        for (const v of vulnerabilities)
+            pipeline.addFinding(vulnerabilityFinding(v));
+    };
+    const tailers = files.map(path => new FileTailer(path, line => pipeline.ingestLine(line, path), options.fromStart));
+    for (const tailer of tailers)
+        tailer.start();
+    if (files.length)
+        log(`Watching ${files.join(", ")}.`);
+    let flushing = false;
+    const flush = async () => {
+        if (flushing)
+            return;
+        flushing = true;
+        try {
+            await pipeline.flush(send);
+        }
+        finally {
+            flushing = false;
+        }
+    };
+    const timers = [
+        setInterval(() => void flush(), 5_000),
+        setInterval(() => {
+            if (Date.now() - lastRefresh >= (config ? 5 * 60_000 : 60_000))
+                void refresh().catch(e => { fatal = e; });
+        }, 15_000),
+        setInterval(() => void checkDependencies(), 24 * 60 * 60_000),
+    ];
+    void checkDependencies();
+    let stdinDone = !options.stdin;
+    if (options.stdin) {
+        if (options.echo !== false)
+            process.stdout.on("error", () => { });
+        const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
+        lines.on("line", line => {
+            if (options.echo !== false)
+                process.stdout.write(`${line}\n`);
+            pipeline.ingestLine(line, "stdin");
+        });
+        lines.on("close", () => { stdinDone = true; });
+    }
+    let stopping = false;
+    const stop = () => { stopping = true; };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    // Runs until stopped or revoked; when reading only a pipe, also until the piped app exits.
+    const endsWithStdin = Boolean(options.stdin) && !files.length;
+    while (!stopping && !fatal && !(endsWithStdin && stdinDone))
+        await sleep(250);
+    for (const timer of timers)
+        clearInterval(timer);
+    for (const tailer of tailers)
+        tailer.stop();
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
+    // Last flush, bounded so a dead network can't hold up shutdown.
+    let giveUp;
+    await Promise.race([flush(), new Promise(r => { giveUp = setTimeout(r, 5_000); })]);
+    clearTimeout(giveUp);
+    if (fatal)
+        throw fatal;
+}
+const fmt = (n) => (n >= 2_147_483_647 ? "unlimited" : n.toLocaleString("en-US"));
+export async function monitorStatus(write = console.log) {
+    const identity = await readIdentity();
+    if (!identity) {
+        write("Not connected to a Beam workspace. Run 'beam connect' first.");
+        return 1;
+    }
+    const result = await fetchMonitorConfig(identity);
+    if (!result.ok) {
+        write(result.status === "disabled" ? `App monitoring: off\n${result.message}` : result.message);
+        return result.status === "disabled" ? 0 : 1;
+    }
+    const { level, llm, webhooks, usage, limits, resetAt, settingsUrl } = result.config;
+    let own = null;
+    let ownError = "";
+    try {
+        own = ownLlmConfig();
+    }
+    catch (error) {
+        ownError = error.message;
+    }
+    write([
+        "App monitoring: on",
+        `Level:          ${level}`,
+        `LLM checks:     ${own ? `your own model, ${own.model} at ${new URL(own.baseUrl).host}` : ownError ? `misconfigured: ${ownError}` : llm ? "Beam's model" : "off"}`,
+        `Webhooks:       ${webhooks}`,
+        `This month:     ${fmt(usage.findings)} / ${fmt(limits.findings)} findings · ${fmt(usage.cveChecks)} / ${fmt(limits.cveChecks)} dependency checks · ${fmt(usage.llmChecks)} / ${fmt(limits.llmChecks)} LLM checks (resets ${resetAt.slice(0, 10)})`,
+        `Settings:       ${settingsUrl}`,
+    ].join("\n"));
+    return 0;
+}
+//# sourceMappingURL=monitor.js.map