forkit-ai-footprints 0.2.0

package/dist/agents.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyAgentProcessTrees = classifyAgentProcessTrees;
+exports.parseMacosCpuTime = parseMacosCpuTime;
+exports.detectAgentProducts = detectAgentProducts;
+exports.listSystemProcesses = listSystemProcesses;
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const hash_1 = require("./hash");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const SIGNATURES = [
+    { signature: 'codex', name: 'Codex', kind: 'coding-agent', terms: ['codex'], executables: ['codex'] },
+    { signature: 'claude', name: 'Claude Code', kind: 'coding-agent', terms: ['claude', 'claude-code'], executables: ['claude'] },
+    { signature: 'aider', name: 'Aider', kind: 'coding-agent', terms: ['aider'], executables: ['aider'] },
+    { signature: 'openhands', name: 'OpenHands', kind: 'coding-agent', terms: ['openhands'], executables: ['openhands'] },
+    { signature: 'goose', name: 'Goose', kind: 'coding-agent', terms: ['goose'], executables: ['goose'] },
+    { signature: 'cursor', name: 'Cursor', kind: 'ide-agent', terms: ['cursor'], executables: ['cursor'] },
+    { signature: 'windsurf', name: 'Windsurf', kind: 'ide-agent', terms: ['windsurf'], executables: ['windsurf'] },
+    { signature: 'gemini-cli', name: 'Gemini CLI', kind: 'coding-agent', terms: ['gemini', 'gemini-cli'], executables: ['gemini'] },
+    { signature: 'opencode', name: 'OpenCode', kind: 'coding-agent', terms: ['opencode'], executables: ['opencode'] },
+    { signature: 'openclaw', name: 'OpenClaw', kind: 'coding-agent', terms: ['openclaw'], executables: ['openclaw'] },
+    { signature: 'cline', name: 'Cline', kind: 'ide-agent', terms: ['cline'], executables: ['cline'] },
+    { signature: 'roo-code', name: 'Roo Code', kind: 'ide-agent', terms: ['roo-code', 'roo_code'], executables: ['roo-code', 'roo_code'] },
+    { signature: 'mcp-server', name: 'MCP Server', kind: 'mcp-server', terms: ['mcp-server', 'modelcontextprotocol'], executables: ['mcp-server'] },
+    { signature: 'langchain', name: 'LangChain', kind: 'agent-framework', terms: ['langchain'], executables: ['langchain'] },
+    { signature: 'langgraph', name: 'LangGraph', kind: 'agent-framework', terms: ['langgraph'], executables: ['langgraph'] },
+    { signature: 'crewai', name: 'CrewAI', kind: 'agent-framework', terms: ['crewai'], executables: ['crewai'] },
+    { signature: 'autogen', name: 'AutoGen', kind: 'agent-framework', terms: ['autogen'], executables: ['autogen'] },
+    { signature: 'llamaindex', name: 'LlamaIndex', kind: 'agent-framework', terms: ['llamaindex'], executables: ['llamaindex'] },
+    { signature: 'agno', name: 'Agno', kind: 'agent-framework', terms: ['agno'], executables: ['agno'] },
+    { signature: 'pydantic-ai', name: 'PydanticAI', kind: 'agent-framework', terms: ['pydantic-ai', 'pydantic_ai'], executables: ['pydantic-ai', 'pydantic_ai'] },
+    { signature: 'smolagents', name: 'smolagents', kind: 'agent-framework', terms: ['smolagents'], executables: ['smolagents'] },
+];
+function basename(value) {
+    const normalized = String(value || '').replaceAll('\\', '/');
+    return node_path_1.default.posix.basename(normalized).toLowerCase().replace(/\.exe$/i, '');
+}
+function commandParts(value) {
+    return String(value || '')
+        .match(/"[^"]*"|'[^']*'|\S+/g)
+        ?.map((part) => part.replace(/^(?:"|')|(?:"|')$/g, '')) ?? [];
+}
+function moduleName(parts) {
+    const moduleFlag = parts.findIndex((part) => part === '-m');
+    if (moduleFlag < 0)
+        return null;
+    const raw = parts[moduleFlag + 1]?.toLowerCase();
+    return raw?.split('.')[0] ?? null;
+}
+function packageRunnerName(parts) {
+    const runner = basename(parts[0] ?? '');
+    let candidates = [];
+    if (runner === 'npx' || runner === 'bunx')
+        candidates = parts.slice(1);
+    else if (runner === 'npm' && (parts[1] === 'exec' || parts[1] === 'x'))
+        candidates = parts.slice(2);
+    else if (runner === 'pnpm' && (parts[1] === 'dlx' || parts[1] === 'exec'))
+        candidates = parts.slice(2);
+    else if (runner === 'yarn' && (parts[1] === 'dlx' || parts[1] === 'exec'))
+        candidates = parts.slice(2);
+    const candidate = candidates.find((part) => part !== '--' && !part.startsWith('-'));
+    if (!candidate)
+        return null;
+    const packageName = candidate.replace(/@(?:latest|next|beta|alpha|canary|\d[^/]*)$/i, '');
+    return basename(packageName);
+}
+function nodeBinName(parts) {
+    const runner = basename(parts[0] ?? '');
+    if (runner !== 'node' && runner !== 'bun' && runner !== 'deno')
+        return null;
+    const script = String(parts[1] ?? '').replaceAll('\\', '/').toLowerCase();
+    if (!script.includes('/.bin/'))
+        return null;
+    return basename(script);
+}
+function classifyProcess(entry) {
+    const processName = basename(entry.name ?? '');
+    const command = String(entry.cmd ?? '');
+    const parts = commandParts(command);
+    const firstCommandToken = parts[0] ?? '';
+    const executable = basename(firstCommandToken || processName) || 'unknown';
+    const invokedModule = moduleName(parts);
+    const invokedPackage = packageRunnerName(parts) ?? nodeBinName(parts);
+    for (const signature of SIGNATURES) {
+        const executableMatch = signature.executables.includes(processName)
+            || signature.executables.includes(executable);
+        const moduleMatch = invokedModule !== null && signature.terms.includes(invokedModule);
+        const packageRunnerMatch = invokedPackage !== null
+            && [...signature.terms, ...signature.executables].includes(invokedPackage);
+        if (!executableMatch && !moduleMatch && !packageRunnerMatch)
+            continue;
+        const confidence = executableMatch ? 'high' : 'medium';
+        const reason = executableMatch
+            ? 'exact_executable_match'
+            : moduleMatch
+                ? 'explicit_module_invocation'
+                : 'explicit_package_runner_invocation';
+        return {
+            signature,
+            confidence,
+            executable,
+            evidenceHash: (0, hash_1.sha256)(`${signature.signature}:${processName}:${executable}:${reason}`),
+            reason,
+            cpuPercent: Number.isFinite(entry.cpu_percent) ? Math.max(0, Number(entry.cpu_percent)) : null,
+            memoryPercent: Number.isFinite(entry.memory_percent) ? Math.max(0, Number(entry.memory_percent)) : null,
+        };
+    }
+    return null;
+}
+function descendantsOf(processes, rootPid) {
+    const excluded = new Set([rootPid]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const entry of processes) {
+            if (excluded.has(entry.pid) || entry.ppid === undefined || !excluded.has(entry.ppid))
+                continue;
+            excluded.add(entry.pid);
+            changed = true;
+        }
+    }
+    return excluded;
+}
+/**
+ * Builds private process-tree evidence for the activity monitor. PIDs and raw
+ * commands remain internal and are deliberately absent from public reports.
+ */
+function classifyAgentProcessTrees(processes, excludedRootPid = process.pid) {
+    const excluded = excludedRootPid === null ? new Set() : descendantsOf(processes, excludedRootPid);
+    const byPid = new Map(processes.map((entry) => [entry.pid, entry]));
+    const direct = new Map();
+    for (const entry of processes) {
+        if (excluded.has(entry.pid))
+            continue;
+        const evidence = classifyProcess(entry);
+        if (evidence)
+            direct.set(entry.pid, evidence);
+    }
+    const result = [];
+    for (const entry of processes) {
+        if (excluded.has(entry.pid))
+            continue;
+        let owner = direct.get(entry.pid) ?? null;
+        let relationship = 'direct';
+        if (!owner) {
+            const visited = new Set();
+            let parentPid = entry.ppid;
+            for (let depth = 0; parentPid !== undefined && parentPid > 0 && depth < 24; depth += 1) {
+                if (visited.has(parentPid) || excluded.has(parentPid))
+                    break;
+                visited.add(parentPid);
+                owner = direct.get(parentPid) ?? null;
+                if (owner) {
+                    relationship = 'descendant';
+                    break;
+                }
+                parentPid = byPid.get(parentPid)?.ppid;
+            }
+        }
+        if (!owner)
+            continue;
+        result.push({
+            pid: entry.pid,
+            ppid: entry.ppid ?? null,
+            signature: owner.signature.signature,
+            name: owner.signature.name,
+            kind: owner.signature.kind,
+            confidence: owner.confidence,
+            relationship,
+            cpu_percent: Number.isFinite(entry.cpu_percent) ? Math.max(0, Number(entry.cpu_percent)) : null,
+            memory_percent: Number.isFinite(entry.memory_percent) ? Math.max(0, Number(entry.memory_percent)) : null,
+            cpu_time_ms: Number.isFinite(entry.cpu_time_ms) ? Math.max(0, Number(entry.cpu_time_ms)) : null,
+        });
+    }
+    return result.sort((left, right) => left.signature.localeCompare(right.signature) || left.pid - right.pid);
+}
+function parseMacosCpuTime(value) {
+    const match = /^(?:(\d+)-)?(?:(\d+):)?(\d+):(\d+(?:\.\d+)?)$/.exec(value.trim());
+    if (!match)
+        return null;
+    const days = Number(match[1] ?? 0);
+    const hours = Number(match[2] ?? 0);
+    const minutes = Number(match[3] ?? 0);
+    const seconds = Number(match[4] ?? 0);
+    if (![days, hours, minutes, seconds].every(Number.isFinite))
+        return null;
+    return Math.round((((days * 24 + hours) * 60 + minutes) * 60 + seconds) * 1000);
+}
+async function macosProcessMetrics() {
+    if (process.platform !== 'darwin')
+        return new Map();
+    try {
+        const { stdout } = await execFileAsync('ps', ['-axo', 'pid=,time=,rss='], {
+            encoding: 'utf8',
+            maxBuffer: 16_000_000,
+            env: { ...process.env, LC_ALL: 'C', LANG: 'C' },
+        });
+        const result = new Map();
+        for (const line of stdout.split('\n')) {
+            const match = /^\s*(\d+)\s+(\S+)\s+(\d+)\s*$/.exec(line);
+            if (!match)
+                continue;
+            const value = parseMacosCpuTime(match[2]);
+            const rssKilobytes = Number(match[3]);
+            if (value !== null && Number.isFinite(rssKilobytes)) {
+                result.set(Number(match[1]), { cpuTimeMs: value, rssBytes: Math.max(0, rssKilobytes) * 1024 });
+            }
+        }
+        return result;
+    }
+    catch {
+        return new Map();
+    }
+}
+function confidenceRank(confidence) {
+    return confidence === 'high' ? 3 : confidence === 'medium' ? 2 : 1;
+}
+function detectAgentProducts(processes) {
+    const grouped = new Map();
+    for (const process of processes) {
+        const evidence = classifyProcess(process);
+        if (!evidence)
+            continue;
+        grouped.set(evidence.signature.signature, [
+            ...(grouped.get(evidence.signature.signature) ?? []),
+            evidence,
+        ]);
+    }
+    return [...grouped.entries()].map(([signature, evidence]) => {
+        const definition = evidence[0].signature;
+        const strongestEvidence = [...evidence]
+            .sort((left, right) => confidenceRank(right.confidence) - confidenceRank(left.confidence))[0];
+        const strongest = strongestEvidence.confidence;
+        return {
+            agent_id: (0, hash_1.stableId)('agent', signature),
+            name: definition.name,
+            signature,
+            kind: definition.kind,
+            confidence: strongest,
+            instance_count: evidence.length,
+            executable_names: [...new Set(evidence.map((entry) => entry.executable))].sort(),
+            evidence_hashes: [...new Set(evidence.map((entry) => entry.evidenceHash))].sort(),
+            detection_reason: strongestEvidence.reason,
+            evidence_status: 'online',
+            resource_snapshot: {
+                cpu_percent: aggregateMetric(evidence.map((entry) => entry.cpuPercent)),
+                memory_percent: aggregateMetric(evidence.map((entry) => entry.memoryPercent)),
+                measurement: 'point-in-time-process-metadata',
+            },
+        };
+    }).sort((left, right) => left.name.localeCompare(right.name));
+}
+function aggregateMetric(values) {
+    const measured = values.filter((value) => value !== null);
+    if (measured.length === 0)
+        return null;
+    return Math.round(measured.reduce((total, value) => total + value, 0) * 10) / 10;
+}
+async function listSystemProcesses() {
+    const dynamicImport = new Function('specifier', 'return import(specifier);');
+    const imported = await dynamicImport('ps-list');
+    const list = imported.default;
+    const [processes, macosMetrics] = await Promise.all([list(), macosProcessMetrics()]);
+    return processes.map((process) => ({
+        pid: process.pid,
+        ppid: process.ppid,
+        name: process.name,
+        ...(process.cmd !== undefined ? { cmd: process.cmd } : {}),
+        ...(Number.isFinite(process.cpu) ? { cpu_percent: Number(process.cpu) } : {}),
+        ...(Number.isFinite(process.memory) ? { memory_percent: Number(process.memory) } : {}),
+        ...(macosMetrics.has(process.pid) ? {
+            cpu_time_ms: macosMetrics.get(process.pid).cpuTimeMs,
+            rss_bytes: macosMetrics.get(process.pid).rssBytes,
+        } : {}),
+    }));
+}
+//# sourceMappingURL=agents.js.map

package/dist/aggregate.d.ts

@@ -0,0 +1,28 @@
+import type { SurfaceMetrics } from './evaluate';
+declare const SURFACES: readonly ["agents", "tools", "runtimes", "models", "mcp"];
+export interface ConfidenceInterval {
+    lower: number;
+    upper: number;
+}
+export interface AggregatedSurfaceMetrics extends SurfaceMetrics {
+    precision_95_interval: ConfidenceInterval | null;
+    recall_95_interval: ConfidenceInterval | null;
+}
+export interface MacosFieldAggregate {
+    aggregation: 'macos-independent-labelled-devices';
+    schema_version: '1.0';
+    product_version: string;
+    evaluation_count: number;
+    coverage: {
+        architecture: Record<string, number>;
+        macos_major: Record<string, number>;
+        node_major: Record<string, number>;
+    };
+    metrics: Record<(typeof SURFACES)[number], AggregatedSurfaceMetrics>;
+    uploaded: false;
+    field_accuracy_claim_allowed: false;
+}
+export declare function aggregateMacosFieldEvaluations(inputs: unknown[]): MacosFieldAggregate;
+export declare function aggregateMacosFieldEvaluationDirectory(directoryPath: string): Promise<MacosFieldAggregate>;
+export {};
+//# sourceMappingURL=aggregate.d.ts.map

package/dist/aggregate.js

@@ -0,0 +1,151 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateMacosFieldEvaluations = aggregateMacosFieldEvaluations;
+exports.aggregateMacosFieldEvaluationDirectory = aggregateMacosFieldEvaluationDirectory;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const SURFACES = ['agents', 'tools', 'runtimes', 'models', 'mcp'];
+function finiteNonNegativeInteger(value, label) {
+    if (!Number.isInteger(value) || Number(value) < 0)
+        throw new Error(`${label} must be a non-negative integer.`);
+    return Number(value);
+}
+function finitePositiveInteger(value, label) {
+    const parsed = finiteNonNegativeInteger(value, label);
+    if (parsed === 0)
+        throw new Error(`${label} must be positive.`);
+    return parsed;
+}
+function parseMetric(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${label} must be an object.`);
+    const record = value;
+    const truePositive = finiteNonNegativeInteger(record.true_positive, `${label}.true_positive`);
+    const falsePositive = finiteNonNegativeInteger(record.false_positive, `${label}.false_positive`);
+    const falseNegative = finiteNonNegativeInteger(record.false_negative, `${label}.false_negative`);
+    const actualCount = truePositive + falsePositive;
+    const expectedCount = truePositive + falseNegative;
+    return {
+        actual_count: actualCount,
+        expected_count: expectedCount,
+        true_positive: truePositive,
+        false_positive: falsePositive,
+        false_negative: falseNegative,
+        precision: actualCount === 0 ? null : truePositive / actualCount,
+        recall: expectedCount === 0 ? null : truePositive / expectedCount,
+    };
+}
+function parseEvaluation(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Evaluation must be an object.');
+    const record = value;
+    if (record.evaluation !== 'macos-local-labelled-device' || record.schema_version !== '1.0') {
+        throw new Error('Unsupported macOS field evaluation.');
+    }
+    if (record.uploaded !== false || record.field_accuracy_claim_allowed !== false) {
+        throw new Error('Evaluation privacy flags are invalid.');
+    }
+    const environment = record.environment;
+    if (!environment || environment.platform !== 'darwin' || typeof environment.architecture !== 'string' || !environment.architecture) {
+        throw new Error('Evaluation environment is invalid.');
+    }
+    const macosMajor = environment.macos_major === null
+        ? null
+        : finitePositiveInteger(environment.macos_major, 'environment.macos_major');
+    const nodeMajor = finitePositiveInteger(environment.node_major, 'environment.node_major');
+    const metricsRecord = record.metrics;
+    if (!metricsRecord)
+        throw new Error('Evaluation metrics are missing.');
+    const productVersion = record.product_version;
+    if (typeof productVersion !== 'string' || !productVersion)
+        throw new Error('Evaluation product version is invalid.');
+    const metrics = Object.fromEntries(SURFACES.map((surface) => [surface, parseMetric(metricsRecord[surface], `metrics.${surface}`)]));
+    return {
+        evaluation: 'macos-local-labelled-device',
+        schema_version: '1.0',
+        product_version: productVersion,
+        environment: {
+            platform: 'darwin',
+            architecture: environment.architecture,
+            macos_major: macosMajor,
+            node_major: nodeMajor,
+        },
+        metrics: metrics,
+        uploaded: false,
+        field_accuracy_claim_allowed: false,
+    };
+}
+function wilson(successes, total) {
+    if (total === 0)
+        return null;
+    const z = 1.959963984540054;
+    const proportion = successes / total;
+    const denominator = 1 + (z * z) / total;
+    const center = (proportion + (z * z) / (2 * total)) / denominator;
+    const margin = (z / denominator) * Math.sqrt((proportion * (1 - proportion)) / total + (z * z) / (4 * total * total));
+    return { lower: Math.max(0, center - margin), upper: Math.min(1, center + margin) };
+}
+function countValues(values) {
+    const counts = new Map();
+    for (const value of values) {
+        const key = value === null ? 'unknown' : String(value);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return Object.fromEntries([...counts.entries()].sort(([left], [right]) => left.localeCompare(right)));
+}
+function aggregateMacosFieldEvaluations(inputs) {
+    if (inputs.length === 0)
+        throw new Error('At least one macOS field evaluation is required.');
+    const evaluations = inputs.map(parseEvaluation);
+    const productVersions = new Set(evaluations.map((evaluation) => evaluation.product_version));
+    if (productVersions.size !== 1)
+        throw new Error('Cannot aggregate evaluations from different product versions.');
+    const metrics = Object.fromEntries(SURFACES.map((surface) => {
+        const sums = evaluations.reduce((total, evaluation) => {
+            const metric = evaluation.metrics[surface];
+            total.truePositive += metric.true_positive;
+            total.falsePositive += metric.false_positive;
+            total.falseNegative += metric.false_negative;
+            return total;
+        }, { truePositive: 0, falsePositive: 0, falseNegative: 0 });
+        const actualCount = sums.truePositive + sums.falsePositive;
+        const expectedCount = sums.truePositive + sums.falseNegative;
+        return [surface, {
+                actual_count: actualCount,
+                expected_count: expectedCount,
+                true_positive: sums.truePositive,
+                false_positive: sums.falsePositive,
+                false_negative: sums.falseNegative,
+                precision: actualCount === 0 ? null : sums.truePositive / actualCount,
+                recall: expectedCount === 0 ? null : sums.truePositive / expectedCount,
+                precision_95_interval: wilson(sums.truePositive, actualCount),
+                recall_95_interval: wilson(sums.truePositive, expectedCount),
+            }];
+    }));
+    return {
+        aggregation: 'macos-independent-labelled-devices',
+        schema_version: '1.0',
+        product_version: evaluations[0].product_version,
+        evaluation_count: evaluations.length,
+        coverage: {
+            architecture: countValues(evaluations.map((evaluation) => evaluation.environment.architecture)),
+            macos_major: countValues(evaluations.map((evaluation) => evaluation.environment.macos_major)),
+            node_major: countValues(evaluations.map((evaluation) => evaluation.environment.node_major)),
+        },
+        metrics: metrics,
+        uploaded: false,
+        field_accuracy_claim_allowed: false,
+    };
+}
+async function aggregateMacosFieldEvaluationDirectory(directoryPath) {
+    const directory = node_path_1.default.resolve(directoryPath);
+    const entries = (await promises_1.default.readdir(directory, { withFileTypes: true }))
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+        .sort((left, right) => left.name.localeCompare(right.name));
+    const inputs = await Promise.all(entries.map(async (entry) => JSON.parse(await promises_1.default.readFile(node_path_1.default.join(directory, entry.name), 'utf8'))));
+    return aggregateMacosFieldEvaluations(inputs);
+}
+//# sourceMappingURL=aggregate.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Info.plist

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>CFBundleDevelopmentRegion</key><string>en</string><key>CFBundleDisplayName</key><string>Forkit AI Footprint</string><key>CFBundleExecutable</key><string>Forkit AI Footprint</string><key>CFBundleIconFile</key><string>ForkitAIFootprint</string><key>CFBundleIdentifier</key><string>dev.forkit.ai-footprints</string><key>CFBundleInfoDictionaryVersion</key><string>6.0</string><key>CFBundleName</key><string>Forkit AI Footprint</string><key>CFBundlePackageType</key><string>APPL</string><key>CFBundleShortVersionString</key><string>0.2.0</string><key>CFBundleVersion</key><string>1</string><key>LSMinimumSystemVersion</key><string>14.0</string>
+</dict></plist>

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/agents.d.ts

@@ -0,0 +1,22 @@
+import type { CensusAgent, Confidence, ProcessEntry } from './types';
+export interface ClassifiedAgentProcess {
+    pid: number;
+    ppid: number | null;
+    signature: string;
+    name: string;
+    kind: string;
+    confidence: Confidence;
+    relationship: 'direct' | 'descendant';
+    cpu_percent: number | null;
+    memory_percent: number | null;
+    cpu_time_ms: number | null;
+}
+/**
+ * Builds private process-tree evidence for the activity monitor. PIDs and raw
+ * commands remain internal and are deliberately absent from public reports.
+ */
+export declare function classifyAgentProcessTrees(processes: ProcessEntry[], excludedRootPid?: number | null): ClassifiedAgentProcess[];
+export declare function parseMacosCpuTime(value: string): number | null;
+export declare function detectAgentProducts(processes: ProcessEntry[]): CensusAgent[];
+export declare function listSystemProcesses(): Promise<ProcessEntry[]>;
+//# sourceMappingURL=agents.d.ts.map