forkit-connect 0.1.0

package/dist/v1/process-scout.js

@@ -0,0 +1,715 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_PROCESS_SIGNATURES = exports.AI_PROCESS_SIGNATURES = void 0;
+exports.classifyProcessEntry = classifyProcessEntry;
+exports.matchesRuntimeObservation = matchesRuntimeObservation;
+exports.classifyAgentProcessEntry = classifyAgentProcessEntry;
+exports.scanLikelyAiProcesses = scanLikelyAiProcesses;
+exports.scanLikelyAgentProcesses = scanLikelyAgentProcesses;
+const node_crypto_1 = require("node:crypto");
+const ps_list_loader_1 = require("../ps-list-loader");
+const discovery_1 = require("./discovery");
+const RUNTIME_LAUNCHER_TERMS = ['python', 'python3', 'node', 'nodejs', 'bun', 'deno', 'uvicorn', 'gunicorn', 'cargo', 'go'];
+const OPENAI_COMPAT_SERVER_TERMS = [
+    'api_server',
+    'openai',
+    'chat/completions',
+    'chat-completions',
+    'completions',
+    'v1/models',
+    'v1/chat',
+    'inference server',
+];
+const RUNTIME_ENGINE_TERMS = [
+    'vllm',
+    'sglang',
+    'litellm',
+    'tabbyapi',
+    'koboldcpp',
+    'fastchat',
+    'xinference',
+    'mistralrs',
+    'mlx_lm',
+    'mlx-lm',
+    'text-generation-inference',
+    'text_generation_inference',
+    'tensorrt-llm',
+    'tensorrt_llm',
+    'llama.cpp',
+    'llama-server',
+    'localai',
+    'open-webui',
+    'comfyui',
+    'automatic1111',
+    'stable-diffusion-webui',
+    'invokeai',
+];
+const RUNTIME_MODEL_TERMS = [
+    'gguf',
+    'safetensors',
+    'huggingface',
+    'transformers',
+    'diffusers',
+    '--model',
+    '-m ',
+    'embedding',
+    'inference',
+];
+const AGENT_LAUNCHER_TERMS = ['python', 'python3', 'node', 'nodejs', 'bun', 'deno'];
+const AGENT_FRAMEWORK_TERMS = [
+    'langgraph',
+    'haystack',
+    'semantic-kernel',
+    'semantic_kernel',
+    'dspy',
+    'smolagents',
+    'agno',
+    'pydantic-ai',
+    'pydantic_ai',
+    'openhands',
+    'aider',
+    'cline',
+    'roo-code',
+    'roo_code',
+    'goose',
+    'mastra',
+];
+const AGENT_ORCHESTRATION_TERMS = [
+    'agent',
+    'assistant',
+    'planner',
+    'orchestrator',
+    'workflow',
+    'tool calling',
+    'tool-calling',
+    'multi-agent',
+    'autonomous',
+];
+const AGENT_AI_CORE_TERMS = [
+    'llm',
+    'prompt',
+    'openai',
+    'anthropic',
+    'ollama',
+    'mcp',
+    'tool',
+    'reasoning',
+];
+const PORT_CAPTURE_PATTERNS = [
+    /--port(?:=|\s+)(\d{2,5})/g,
+    /(?:^|\s)-p\s+(\d{2,5})(?=\s|$)/g,
+    /(?:localhost|127\.0\.0\.1|0\.0\.0\.0):(\d{2,5})/g,
+    /\bport[=:](\d{2,5})\b/gi,
+];
+exports.AI_PROCESS_SIGNATURES = [
+    {
+        signature: 'ollama',
+        knownProvider: 'ollama',
+        providerHints: ['ollama'],
+        aliases: ['ollama'],
+        match: (processName, command) => processName.includes('ollama') || command.includes('ollama'),
+    },
+    {
+        signature: 'lmstudio',
+        knownProvider: 'lmstudio',
+        providerHints: ['lmstudio'],
+        aliases: ['lmstudio', 'lm studio'],
+        match: (processName, command) => processName.includes('lmstudio') || command.includes('lm studio'),
+    },
+    {
+        signature: 'llama.cpp',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [8080],
+        aliases: ['llama.cpp'],
+        match: (processName, command) => processName.includes('llama.cpp') || command.includes('llama.cpp'),
+    },
+    {
+        signature: 'llama-server',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [8080],
+        aliases: ['llama-server'],
+        match: (processName, command) => processName.includes('llama-server') || command.includes('llama-server'),
+    },
+    {
+        signature: 'vllm',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [8000],
+        aliases: ['vllm', 'api_server'],
+        match: (processName, command) => processName.includes('vllm') || command.includes(' vllm') || command.includes('vllm.'),
+    },
+    {
+        signature: 'localai',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [8080],
+        aliases: ['localai'],
+        match: (processName, command) => processName.includes('localai') || command.includes('localai'),
+    },
+    {
+        signature: 'text-generation-inference',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [3000, 8080],
+        aliases: ['text-generation-inference', 'text_generation_inference', 'tgi'],
+        match: (processName, command) => processName.includes('text-generation-inference') || command.includes('text-generation-inference') || command.includes('text_generation_inference') || command.includes('tgi'),
+    },
+    {
+        signature: 'sglang',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [30000, 8000],
+        aliases: ['sglang'],
+        match: (processName, command) => processName.includes('sglang') || command.includes('sglang'),
+    },
+    {
+        signature: 'litellm',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [4000, 8000],
+        aliases: ['litellm'],
+        match: (processName, command) => processName.includes('litellm') || command.includes('litellm'),
+    },
+    {
+        signature: 'tabbyapi',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [5000, 8080],
+        aliases: ['tabbyapi', 'tabby api'],
+        match: (processName, command) => processName.includes('tabbyapi') || command.includes('tabbyapi') || command.includes('tabby api'),
+    },
+    {
+        signature: 'koboldcpp',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [5001],
+        aliases: ['koboldcpp', 'kobold.cpp'],
+        match: (processName, command) => processName.includes('koboldcpp') || command.includes('koboldcpp') || command.includes('kobold.cpp'),
+    },
+    {
+        signature: 'fastchat',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [8000, 21002],
+        aliases: ['fastchat'],
+        match: (processName, command) => processName.includes('fastchat') || command.includes('fastchat'),
+    },
+    {
+        signature: 'xinference',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [9997],
+        aliases: ['xinference'],
+        match: (processName, command) => processName.includes('xinference') || command.includes('xinference'),
+    },
+    {
+        signature: 'mistralrs',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [8080],
+        aliases: ['mistralrs', 'mistral.rs'],
+        match: (processName, command) => processName.includes('mistralrs') || command.includes('mistralrs') || command.includes('mistral.rs'),
+    },
+    {
+        signature: 'mlx-lm',
+        knownProvider: null,
+        providerHints: ['openai-compatible'],
+        expectedPorts: [8080],
+        aliases: ['mlx-lm', 'mlx_lm'],
+        match: (processName, command) => processName.includes('mlx-lm') || command.includes('mlx-lm') || command.includes('mlx_lm'),
+    },
+    {
+        signature: 'comfyui',
+        knownProvider: null,
+        expectedPorts: [8188],
+        aliases: ['comfyui'],
+        match: (processName, command) => processName.includes('comfyui') || command.includes('comfyui'),
+    },
+    {
+        signature: 'automatic1111',
+        knownProvider: null,
+        expectedPorts: [7860],
+        aliases: ['automatic1111', 'stable-diffusion-webui'],
+        match: (processName, command) => processName.includes('automatic1111')
+            || command.includes('automatic1111')
+            || command.includes('stable-diffusion-webui'),
+    },
+    {
+        signature: 'invokeai',
+        knownProvider: null,
+        expectedPorts: [9090],
+        aliases: ['invokeai'],
+        match: (processName, command) => processName.includes('invokeai') || command.includes('invokeai'),
+    },
+    {
+        signature: 'python-ai-runtime',
+        knownProvider: null,
+        aliases: ['python', 'vllm', 'llama', 'transformers'],
+        confidence: 'medium',
+        sourceLabel: 'Detected by Python AI runtime signature',
+        match: (processName, command) => processName.startsWith('python')
+            && (command.includes('vllm')
+                || command.includes('llama')
+                || command.includes('transformers')
+                || command.includes('diffusers')),
+    },
+];
+exports.AGENT_PROCESS_SIGNATURES = [
+    {
+        signature: 'codex',
+        agentType: 'coding_agent',
+        agentName: 'Codex',
+        aliases: ['codex'],
+        match: (processName, command) => processName.includes('codex') || command.includes(' codex') || command.includes('/codex'),
+    },
+    {
+        signature: 'claude',
+        agentType: 'coding_agent',
+        agentName: 'Claude',
+        aliases: ['claude'],
+        match: (processName, command) => processName.includes('claude') || command.includes(' claude') || command.includes('/claude'),
+    },
+    {
+        signature: 'aider',
+        agentType: 'coding_agent',
+        agentName: 'Aider',
+        aliases: ['aider'],
+        match: (processName, command) => processName.includes('aider') || command.includes(' aider'),
+    },
+    {
+        signature: 'cursor',
+        agentType: 'ide_extension',
+        agentName: 'Cursor',
+        aliases: ['cursor'],
+        match: (processName, command) => processName.includes('cursor') || command.includes('cursor'),
+    },
+    {
+        signature: 'windsurf',
+        agentType: 'ide_extension',
+        agentName: 'Windsurf',
+        aliases: ['windsurf'],
+        match: (processName, command) => processName.includes('windsurf') || command.includes('windsurf'),
+    },
+    {
+        signature: 'cline',
+        agentType: 'ide_extension',
+        agentName: 'Cline',
+        aliases: ['cline'],
+        match: (processName, command) => processName.includes('cline') || command.includes('cline'),
+    },
+    {
+        signature: 'roo-code',
+        agentType: 'ide_extension',
+        agentName: 'Roo Code',
+        aliases: ['roo-code', 'roo_code'],
+        match: (processName, command) => processName.includes('roo-code') || command.includes('roo-code') || command.includes('roo_code'),
+    },
+    {
+        signature: 'vscode-agent',
+        agentType: 'ide_extension',
+        agentName: 'VS Code AI Tooling',
+        aliases: ['vscode', 'code', 'mcp', 'copilot', 'agent'],
+        match: (processName, command) => (processName === 'code' || processName.includes('vscode'))
+            && (command.includes('mcp') || command.includes('copilot') || command.includes('agent')),
+    },
+    {
+        signature: 'mcp-server',
+        agentType: 'mcp_server',
+        agentName: 'MCP Server',
+        aliases: ['mcp', 'model context protocol'],
+        match: (processName, command) => processName.includes('mcp') || command.includes(' mcp') || command.includes('model context protocol'),
+    },
+    {
+        signature: 'langchain',
+        agentType: 'local_agent_runtime',
+        agentName: 'LangChain Tooling',
+        aliases: ['langchain'],
+        match: (processName, command) => processName.includes('langchain') || command.includes('langchain'),
+    },
+    {
+        signature: 'llamaindex',
+        agentType: 'local_agent_runtime',
+        agentName: 'LlamaIndex Tooling',
+        aliases: ['llamaindex'],
+        match: (processName, command) => processName.includes('llamaindex') || command.includes('llamaindex'),
+    },
+    {
+        signature: 'langgraph',
+        agentType: 'local_agent_runtime',
+        agentName: 'LangGraph Tooling',
+        aliases: ['langgraph'],
+        match: (processName, command) => processName.includes('langgraph') || command.includes('langgraph'),
+    },
+    {
+        signature: 'haystack',
+        agentType: 'local_agent_runtime',
+        agentName: 'Haystack Tooling',
+        aliases: ['haystack'],
+        match: (processName, command) => processName.includes('haystack') || command.includes('haystack'),
+    },
+    {
+        signature: 'semantic-kernel',
+        agentType: 'local_agent_runtime',
+        agentName: 'Semantic Kernel Tooling',
+        aliases: ['semantic-kernel', 'semantic_kernel'],
+        match: (processName, command) => processName.includes('semantic-kernel')
+            || command.includes('semantic-kernel')
+            || command.includes('semantic_kernel'),
+    },
+    {
+        signature: 'dspy',
+        agentType: 'local_agent_runtime',
+        agentName: 'DSPy Tooling',
+        aliases: ['dspy'],
+        match: (processName, command) => processName.includes('dspy') || command.includes('dspy'),
+    },
+    {
+        signature: 'smolagents',
+        agentType: 'local_agent_runtime',
+        agentName: 'smolagents Tooling',
+        aliases: ['smolagents'],
+        match: (processName, command) => processName.includes('smolagents') || command.includes('smolagents'),
+    },
+    {
+        signature: 'agno',
+        agentType: 'local_agent_runtime',
+        agentName: 'Agno Tooling',
+        aliases: ['agno'],
+        match: (processName, command) => processName.includes('agno') || command.includes('agno'),
+    },
+    {
+        signature: 'pydantic-ai',
+        agentType: 'local_agent_runtime',
+        agentName: 'PydanticAI Tooling',
+        aliases: ['pydantic-ai', 'pydantic_ai'],
+        match: (processName, command) => processName.includes('pydantic-ai')
+            || command.includes('pydantic-ai')
+            || command.includes('pydantic_ai'),
+    },
+    {
+        signature: 'crewai',
+        agentType: 'local_agent_runtime',
+        agentName: 'CrewAI Tooling',
+        aliases: ['crewai'],
+        match: (processName, command) => processName.includes('crewai') || command.includes('crewai'),
+    },
+    {
+        signature: 'autogen',
+        agentType: 'local_agent_runtime',
+        agentName: 'AutoGen Tooling',
+        aliases: ['autogen'],
+        match: (processName, command) => processName.includes('autogen') || command.includes('autogen'),
+    },
+    {
+        signature: 'openhands',
+        agentType: 'coding_agent',
+        agentName: 'OpenHands',
+        aliases: ['openhands'],
+        match: (processName, command) => processName.includes('openhands') || command.includes('openhands'),
+    },
+    {
+        signature: 'claude-code',
+        agentType: 'coding_agent',
+        agentName: 'Claude Code',
+        aliases: ['claude', 'claude-code'],
+        match: (processName, command) => processName === 'claude' ||
+            processName.includes('claude-code') ||
+            command.includes('claude-code') ||
+            (processName.includes('claude') && (command.includes('code') || command.includes('--print') || command.includes('--output-format'))),
+    },
+    {
+        signature: 'n8n',
+        agentType: 'workflow_automation',
+        agentName: 'n8n Workflow Automation',
+        aliases: ['n8n'],
+        match: (processName, command) => processName === 'n8n' || processName.includes('n8n') || command.includes('n8n'),
+    },
+    {
+        signature: 'lovable',
+        agentType: 'coding_agent',
+        agentName: 'Lovable',
+        aliases: ['lovable'],
+        match: (processName, command) => processName.includes('lovable') || command.includes('lovable'),
+    },
+    {
+        signature: 'python-agent-runtime',
+        agentType: 'unknown_ai_tool',
+        agentName: 'Python AI Tool',
+        aliases: ['python', 'agent', 'mcp', 'langchain', 'llamaindex', 'crewai', 'autogen'],
+        confidence: 'medium',
+        sourceLabel: 'Detected by Python AI tool signature',
+        match: (processName, command) => processName.startsWith('python')
+            && ['agent', 'mcp', 'langchain', 'llamaindex', 'crewai', 'autogen', 'langgraph', 'haystack'].some((term) => command.includes(term)),
+    },
+];
+function shaFragment(value) {
+    return (0, node_crypto_1.createHash)('sha256').update(value, 'utf8').digest('hex').slice(0, 16);
+}
+function normalizeText(value) {
+    return String(value || '').trim().toLowerCase();
+}
+function tokenizeCommand(command) {
+    return command.split(/\s+/).map((token) => token.trim()).filter(Boolean);
+}
+function basenameFromToken(token) {
+    if (!token)
+        return 'unknown';
+    const normalized = token.replace(/\\/g, '/');
+    const parts = normalized.split('/').filter(Boolean);
+    return parts[parts.length - 1] || normalized;
+}
+function uniqueStrings(values) {
+    return [...new Set(values.map((value) => normalizeText(value)).filter(Boolean))];
+}
+function parseExpectedPortsFromCommand(command) {
+    const ports = new Set();
+    for (const pattern of PORT_CAPTURE_PATTERNS) {
+        for (const match of command.matchAll(pattern)) {
+            const numeric = Number(match[1] || '');
+            if (Number.isInteger(numeric) && numeric >= 1 && numeric <= 65535) {
+                ports.add(numeric);
+            }
+        }
+    }
+    return [...ports].sort((left, right) => left - right);
+}
+function collectMatchedTerms(haystack, terms) {
+    return uniqueStrings(terms.filter((term) => haystack.includes(term)));
+}
+function detectKnownRuntimeSignature(processName, command) {
+    return exports.AI_PROCESS_SIGNATURES.find((candidate) => candidate.match(processName, command)) ?? null;
+}
+function detectKnownAgentSignature(processName, command) {
+    return exports.AGENT_PROCESS_SIGNATURES.find((candidate) => candidate.match(processName, command)) ?? null;
+}
+function inferRuntimeHeuristic(processName, command) {
+    const haystack = `${processName} ${command}`.trim();
+    if (!haystack) {
+        return null;
+    }
+    const launcherTerms = collectMatchedTerms(haystack, RUNTIME_LAUNCHER_TERMS);
+    const engineTerms = collectMatchedTerms(haystack, RUNTIME_ENGINE_TERMS);
+    const serverTerms = collectMatchedTerms(haystack, OPENAI_COMPAT_SERVER_TERMS);
+    const modelTerms = collectMatchedTerms(haystack, RUNTIME_MODEL_TERMS);
+    const explicitPorts = parseExpectedPortsFromCommand(command);
+    const score = (engineTerms.length > 0 ? 3 : 0)
+        + (serverTerms.length > 0 ? 2 : 0)
+        + (modelTerms.length > 0 ? 1 : 0)
+        + (launcherTerms.length > 0 ? 1 : 0)
+        + (explicitPorts.length > 0 ? 1 : 0);
+    const looksLikeRuntime = engineTerms.length > 0 || (serverTerms.length > 0 && modelTerms.length > 0);
+    if (!looksLikeRuntime || score < 3) {
+        return null;
+    }
+    const matchedTerms = uniqueStrings([
+        ...engineTerms,
+        ...serverTerms,
+        ...modelTerms,
+        ...launcherTerms,
+    ]);
+    const providerHints = uniqueStrings([
+        serverTerms.length > 0 || engineTerms.some((term) => term !== 'comfyui' && term !== 'automatic1111' && term !== 'stable-diffusion-webui' && term !== 'invokeai')
+            ? 'openai-compatible'
+            : null,
+    ]);
+    return {
+        signature: 'unknown-ai-runtime',
+        knownProvider: null,
+        providerHints,
+        expectedPorts: explicitPorts,
+        matchedTerms,
+        confidence: engineTerms.length > 0 || explicitPorts.length > 0 ? 'medium' : 'low',
+        sourceLabel: 'Heuristic AI runtime candidate',
+        reason: 'ai_runtime_heuristic_match',
+    };
+}
+function inferAgentHeuristic(processName, command) {
+    const haystack = `${processName} ${command}`.trim();
+    if (!haystack) {
+        return null;
+    }
+    const launcherTerms = collectMatchedTerms(haystack, AGENT_LAUNCHER_TERMS);
+    const frameworkTerms = collectMatchedTerms(haystack, AGENT_FRAMEWORK_TERMS);
+    const orchestrationTerms = collectMatchedTerms(haystack, AGENT_ORCHESTRATION_TERMS);
+    const aiCoreTerms = collectMatchedTerms(haystack, AGENT_AI_CORE_TERMS);
+    const score = (frameworkTerms.length > 0 ? 2 : 0)
+        + (orchestrationTerms.length > 0 ? 1 : 0)
+        + (aiCoreTerms.length > 0 ? 1 : 0)
+        + (launcherTerms.length > 0 ? 1 : 0);
+    const looksLikeAgent = frameworkTerms.length > 0 || (orchestrationTerms.length > 0 && aiCoreTerms.length > 0);
+    if (!looksLikeAgent || score < 3) {
+        return null;
+    }
+    return {
+        signature: 'unknown-ai-tool',
+        agentType: 'unknown_ai_tool',
+        agentName: 'Unknown AI Tool',
+        matchedTerms: uniqueStrings([
+            ...frameworkTerms,
+            ...orchestrationTerms,
+            ...aiCoreTerms,
+            ...launcherTerms,
+        ]),
+        confidence: frameworkTerms.length > 0 ? 'medium' : 'low',
+        sourceLabel: 'Heuristic AI tool candidate',
+        reason: 'ai_agent_heuristic_match',
+    };
+}
+function classifyProcessEntry(entry) {
+    const processName = normalizeText(entry.name);
+    const command = normalizeText(entry.cmd);
+    if (!processName && !command) {
+        return null;
+    }
+    const tokens = tokenizeCommand(command);
+    const firstToken = tokens[0] || processName;
+    const knownSignature = detectKnownRuntimeSignature(processName, command);
+    const heuristic = knownSignature ? null : inferRuntimeHeuristic(processName, command);
+    if (!knownSignature && !heuristic) {
+        return null;
+    }
+    if (knownSignature) {
+        const matchedTerms = uniqueStrings([
+            knownSignature.signature,
+            knownSignature.knownProvider,
+            ...(knownSignature.providerHints ?? []),
+            ...(knownSignature.aliases ?? []),
+        ].filter((term) => typeof term === 'string' && haystackIncludes(processName, command, term)));
+        return {
+            pid: entry.pid,
+            parent_pid: typeof entry.ppid === 'number' ? entry.ppid : null,
+            process_name: processName || 'unknown',
+            executable_name: basenameFromToken(firstToken),
+            signature: knownSignature.signature,
+            known_provider: knownSignature.knownProvider,
+            provider_hints: uniqueStrings(knownSignature.providerHints ?? []),
+            expected_ports: uniqueNumbers([...(knownSignature.expectedPorts ?? []), ...parseExpectedPortsFromCommand(command)]),
+            matched_terms: matchedTerms.length > 0 ? matchedTerms : [knownSignature.signature],
+            command_hash: command ? shaFragment(command) : null,
+            path_hash: firstToken && firstToken.includes('/') ? shaFragment(firstToken) : null,
+            confidence: knownSignature.confidence ?? 'high',
+            detection_mode: 'signature',
+            source_label: knownSignature.sourceLabel ?? 'Detected by known AI runtime signature',
+            reason: `${knownSignature.signature}_signature_match`,
+        };
+    }
+    return {
+        pid: entry.pid,
+        parent_pid: typeof entry.ppid === 'number' ? entry.ppid : null,
+        process_name: processName || 'unknown',
+        executable_name: basenameFromToken(firstToken),
+        signature: heuristic?.signature ?? 'unknown-ai-runtime',
+        known_provider: heuristic?.knownProvider ?? null,
+        provider_hints: heuristic?.providerHints ?? [],
+        expected_ports: heuristic?.expectedPorts ?? [],
+        matched_terms: heuristic?.matchedTerms ?? [],
+        command_hash: command ? shaFragment(command) : null,
+        path_hash: firstToken && firstToken.includes('/') ? shaFragment(firstToken) : null,
+        confidence: heuristic?.confidence ?? 'low',
+        detection_mode: 'heuristic',
+        source_label: heuristic?.sourceLabel ?? 'Heuristic AI runtime candidate',
+        reason: heuristic?.reason ?? 'ai_runtime_heuristic_match',
+    };
+}
+function haystackIncludes(processName, command, term) {
+    const normalized = normalizeText(term);
+    if (!normalized)
+        return false;
+    return processName.includes(normalized) || command.includes(normalized);
+}
+function uniqueNumbers(values) {
+    return [...new Set(values.filter((value) => Number.isInteger(value) && value >= 1 && value <= 65535))].sort((left, right) => left - right);
+}
+function matchesRuntimeObservation(process, runtimeName, runtimeEndpoint) {
+    if (process.known_provider === runtimeName || process.signature === runtimeName) {
+        return true;
+    }
+    if (!process.provider_hints?.includes(runtimeName)) {
+        return false;
+    }
+    if (!process.expected_ports?.length) {
+        return true;
+    }
+    const runtimePort = (0, discovery_1.readEndpointPort)(runtimeEndpoint);
+    return runtimePort !== null && process.expected_ports.includes(runtimePort);
+}
+function classifyAgentProcessEntry(entry) {
+    const processName = normalizeText(entry.name);
+    const command = normalizeText(entry.cmd);
+    if (!processName && !command) {
+        return null;
+    }
+    const tokens = tokenizeCommand(command);
+    const firstToken = tokens[0] || processName;
+    const knownSignature = detectKnownAgentSignature(processName, command);
+    const heuristic = knownSignature ? null : inferAgentHeuristic(processName, command);
+    if (!knownSignature && !heuristic) {
+        return null;
+    }
+    if (knownSignature) {
+        const matchedTerms = uniqueStrings([
+            knownSignature.signature,
+            knownSignature.agentName,
+            ...(knownSignature.aliases ?? []),
+        ].filter((term) => haystackIncludes(processName, command, term)));
+        return {
+            process_name: processName || 'unknown',
+            executable_name: basenameFromToken(firstToken),
+            signature: knownSignature.signature,
+            matched_terms: matchedTerms.length > 0 ? matchedTerms : [knownSignature.signature],
+            command_hash: command ? shaFragment(command) : null,
+            path_hash: firstToken && firstToken.includes('/') ? shaFragment(firstToken) : null,
+            agent_name: knownSignature.agentName,
+            agent_type: knownSignature.agentType,
+            confidence: knownSignature.confidence ?? 'high',
+            detection_mode: 'signature',
+            source_label: knownSignature.sourceLabel ?? 'Detected by known AI tool signature',
+            reason: `${knownSignature.signature}_signature_match`,
+        };
+    }
+    return {
+        process_name: processName || 'unknown',
+        executable_name: basenameFromToken(firstToken),
+        signature: heuristic?.signature ?? 'unknown-ai-tool',
+        matched_terms: heuristic?.matchedTerms ?? [],
+        command_hash: command ? shaFragment(command) : null,
+        path_hash: firstToken && firstToken.includes('/') ? shaFragment(firstToken) : null,
+        agent_name: heuristic?.agentName ?? 'Unknown AI Tool',
+        agent_type: heuristic?.agentType ?? 'unknown_ai_tool',
+        confidence: heuristic?.confidence ?? 'low',
+        detection_mode: 'heuristic',
+        source_label: heuristic?.sourceLabel ?? 'Heuristic AI tool candidate',
+        reason: heuristic?.reason ?? 'ai_agent_heuristic_match',
+    };
+}
+async function scanLikelyAiProcesses(listFn = ps_list_loader_1.listProcesses) {
+    const processes = await listFn();
+    const seen = new Map();
+    for (const entry of processes) {
+        const classified = classifyProcessEntry(entry);
+        if (!classified)
+            continue;
+        const identity = `${classified.signature}:${classified.process_name}:${classified.executable_name}:${classified.command_hash}`;
+        if (!seen.has(identity)) {
+            seen.set(identity, classified);
+        }
+    }
+    return [...seen.values()];
+}
+async function scanLikelyAgentProcesses(listFn = ps_list_loader_1.listProcesses) {
+    const processes = await listFn();
+    const seen = new Map();
+    for (const entry of processes) {
+        const classified = classifyAgentProcessEntry(entry);
+        if (!classified)
+            continue;
+        const identity = `${classified.signature}:${classified.process_name}:${classified.executable_name}:${classified.command_hash}`;
+        if (!seen.has(identity)) {
+            seen.set(identity, classified);
+        }
+    }
+    return [...seen.values()];
+}
+//# sourceMappingURL=process-scout.js.map