forkit-connect 0.1.5 → 0.1.7

package/dist/v1/runtime-observer.js

@@ -0,0 +1,867 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectActiveRuntimeTooling = detectActiveRuntimeTooling;
+exports.extractObservedFolderLabels = extractObservedFolderLabels;
+exports.extractObservedModelLabels = extractObservedModelLabels;
+exports.buildRuntimeObservationSteps = buildRuntimeObservationSteps;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const process_scout_1 = require("./process-scout");
+const TOOLING_DEFINITIONS = [
+    { key: 'antigravity', label: 'Antigravity', binaries: ['antigravity'] },
+    { key: 'cursor', label: 'Cursor', binaries: ['cursor'] },
+    { key: 'vscode', label: 'VS Code', binaries: ['code', 'codium'] },
+    { key: 'claude', label: 'Claude', binaries: ['claude'] },
+    { key: 'codex', label: 'Codex', binaries: ['codex'] },
+    { key: 'anaconda', label: 'Anaconda', binaries: ['conda'] },
+    { key: 'jupyter', label: 'Jupyter', binaries: ['jupyter', 'jupyter-lab', 'jupyter-notebook'] },
+];
+const AGENT_SIGNATURE_TO_TOOL_KEY = {
+    cursor: 'cursor',
+    'vscode-agent': 'vscode',
+    claude: 'claude',
+    'claude-code': 'claude',
+    codex: 'codex',
+};
+function trimOptional(value) {
+    const normalized = String(value ?? '').trim();
+    return normalized.length ? normalized : null;
+}
+function roundMetric(value) {
+    if (value === null || !Number.isFinite(value))
+        return null;
+    return Math.round(value * 100) / 100;
+}
+function bytesToMb(value) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric <= 0)
+        return null;
+    return roundMetric(numeric / (1024 * 1024));
+}
+function cpuValue(value) {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || numeric < 0)
+        return null;
+    return roundMetric(numeric);
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function runtimeRoot(repo) {
+    return node_path_1.default.resolve(repo.rootPath || repo.cwd);
+}
+function runtimeRelativeEntrypoint(repo) {
+    const relative = trimOptional(repo.relativeCwd);
+    return relative || '.';
+}
+function normalizeProcessText(value) {
+    return String(value || '').trim().toLowerCase();
+}
+function processTokens(command) {
+    return command
+        .split(/\s+/)
+        .map((token) => token.trim().toLowerCase())
+        .filter(Boolean);
+}
+function processBasename(token) {
+    const normalized = token.replace(/\\/g, '/');
+    const base = normalized.split('/').filter(Boolean).pop() || normalized;
+    return base.replace(/\.app$/i, '').replace(/\.exe$/i, '').toLowerCase();
+}
+function realpathSafe(value) {
+    const resolved = node_path_1.default.resolve(value);
+    try {
+        const nativeRealpath = node_fs_1.default.realpathSync.native;
+        return typeof nativeRealpath === 'function' ? nativeRealpath(resolved) : node_fs_1.default.realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+function normalizeRelativeToRuntime(repo, value) {
+    const raw = trimOptional(typeof value === 'string' ? value : null);
+    if (!raw)
+        return null;
+    if (raw === '.')
+        return '.';
+    const root = runtimeRoot(repo);
+    if (node_path_1.default.isAbsolute(raw)) {
+        if (!isPathWithinRuntimeRoot(repo, raw))
+            return null;
+        const relative = node_path_1.default.relative(root, raw).replace(/[\\/]+/g, '/');
+        return relative === '' ? '.' : relative;
+    }
+    const normalized = raw.replace(/[\\/]+/g, '/').replace(/^\.\/+/, '');
+    return normalized || '.';
+}
+function uniqueSortedStrings(values) {
+    return [...new Set(values.map((value) => String(value || '').trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right));
+}
+function uniqueSortedNumbers(values) {
+    return [...new Set(values.filter((value) => Number.isFinite(value) && Number(value) > 0).map((value) => Number(value)))]
+        .sort((left, right) => left - right);
+}
+function summarizeObservationList(values, label, maxItems = 3) {
+    const normalized = values
+        .map((value) => String(value ?? '').trim())
+        .filter(Boolean);
+    if (normalized.length === 0)
+        return null;
+    const preview = normalized.slice(0, maxItems).join(', ');
+    const remainder = normalized.length > maxItems ? ` +${normalized.length - maxItems} more` : '';
+    return `${label}: ${preview}${remainder}`;
+}
+function matchesProcessBinary(processName, command, binary) {
+    const normalizedBinary = normalizeProcessText(binary);
+    const normalizedName = normalizeProcessText(processName);
+    const normalizedCommand = normalizeProcessText(command);
+    const boundaryPattern = new RegExp(`(^|[^a-z0-9])${escapeRegExp(normalizedBinary)}(?:\\.app|\\.exe)?($|[^a-z0-9])`, 'i');
+    if (normalizedName === normalizedBinary || boundaryPattern.test(normalizedName)) {
+        return true;
+    }
+    if (normalizedBinary.length > 4 && boundaryPattern.test(normalizedCommand)) {
+        return true;
+    }
+    return processTokens(normalizedCommand).some((token) => processBasename(token) === normalizedBinary);
+}
+function matchesVsCodeProcess(processName, command) {
+    const normalizedName = normalizeProcessText(processName);
+    const normalizedCommand = normalizeProcessText(command);
+    if (matchesProcessBinary(processName, command, 'code') || matchesProcessBinary(processName, command, 'codium')) {
+        return true;
+    }
+    return ((normalizedName.includes('code helper') || normalizedName === 'code')
+        && normalizedCommand.includes('/visual studio code.app/'));
+}
+function matchesCursorProcess(processName, command) {
+    const normalizedName = normalizeProcessText(processName);
+    const normalizedCommand = normalizeProcessText(command);
+    if (matchesProcessBinary(processName, command, 'cursor')) {
+        return true;
+    }
+    return ((normalizedName.includes('cursor helper') || normalizedName === 'cursor')
+        && normalizedCommand.includes('/cursor.app/'));
+}
+function matchesClaudeProcess(processName, command) {
+    const normalizedName = normalizeProcessText(processName);
+    const normalizedCommand = normalizeProcessText(command);
+    if (matchesProcessBinary(processName, command, 'claude')) {
+        return true;
+    }
+    return (normalizedCommand.includes('/claude.app/')
+        || normalizedCommand.includes('claude-mcp-browser-bridge')
+        || (normalizedName.includes('chrome-native-host') && normalizedCommand.includes('/applications/claude.app/')));
+}
+function matchesToolProcess(definition, processName, command) {
+    if (definition.key === 'claude')
+        return matchesClaudeProcess(processName, command);
+    if (definition.key === 'vscode')
+        return matchesVsCodeProcess(processName, command);
+    if (definition.key === 'cursor')
+        return matchesCursorProcess(processName, command);
+    return (definition.binaries ?? []).some((binary) => matchesProcessBinary(processName, command, binary));
+}
+function encodeWorkspacePathMarker(targetPath) {
+    return `file_${targetPath.replace(/\\/g, '/').replace(/^\/+/, '').replace(/[^a-z0-9]+/gi, '_').replace(/^_+|_+$/g, '').toLowerCase()}`;
+}
+function hasRepoScopeEvidence(repo, command) {
+    const normalizedCommand = normalizeProcessText(command);
+    const root = runtimeRoot(repo);
+    const cwd = node_path_1.default.resolve(repo.cwd);
+    const repoRootMarker = realpathSafe(root).replace(/\\/g, '/').toLowerCase();
+    const cwdMarker = realpathSafe(cwd).replace(/\\/g, '/').toLowerCase();
+    const encodedRepoRoot = encodeWorkspacePathMarker(root);
+    const encodedCwd = encodeWorkspacePathMarker(cwd);
+    return [repoRootMarker, cwdMarker, encodedRepoRoot, encodedCwd]
+        .some((marker) => marker.length > 0 && normalizedCommand.includes(marker));
+}
+function isLowSignalHelperProcess(processName, command) {
+    const haystack = `${normalizeProcessText(processName)} ${normalizeProcessText(command)}`;
+    return [
+        'crashpad_handler',
+        '--type=gpu-process',
+        '--type=renderer',
+        '--utility-sub-type=network.',
+        '--utility-sub-type=audio.',
+        '--utility-sub-type=video_capture.',
+        'typingsinstaller.js',
+    ].some((pattern) => haystack.includes(pattern));
+}
+function extractCommandFlagValue(command, flag) {
+    const escapedFlag = escapeRegExp(flag);
+    const match = command.match(new RegExp(`${escapedFlag}(?:=|\\s+)([^\\s]+)`, 'i'));
+    return trimOptional(match?.[1] || null);
+}
+function extractCommandFlagNumber(command, flag) {
+    const raw = extractCommandFlagValue(command, flag);
+    const numeric = Number(raw || '');
+    return Number.isInteger(numeric) ? numeric : null;
+}
+function normalizeExtensionFolderToId(folderName) {
+    const normalized = trimOptional(folderName);
+    if (!normalized)
+        return null;
+    return trimOptional(normalized.replace(/-\d[\w.-]*$/i, ''));
+}
+function extractVsCodeExtensionId(command) {
+    const normalized = String(command || '').replace(/\\/g, '/');
+    const match = normalized.match(/\/\.vscode\/extensions\/([^/\s]+)/i);
+    return normalizeExtensionFolderToId(match?.[1] || null);
+}
+function extractChromeExtensionId(command) {
+    const match = String(command || '').match(/chrome-extension:\/\/([a-z]{32})\b/i);
+    return trimOptional(match?.[1] || null);
+}
+function readJsonFile(targetPath) {
+    try {
+        return JSON.parse(node_fs_1.default.readFileSync(targetPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function collectClaudeTrackedWorktreePaths(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return [];
+    const collected = new Set();
+    const root = value;
+    for (const [key, entry] of Object.entries(root)) {
+        if (typeof key === 'string' && key.startsWith('/')) {
+            collected.add(realpathSafe(key));
+        }
+        if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+            const record = entry;
+            for (const candidate of [record.path, record.worktreePath, record.rootPath]) {
+                if (typeof candidate === 'string' && candidate.startsWith('/')) {
+                    collected.add(realpathSafe(candidate));
+                }
+            }
+        }
+    }
+    return [...collected].sort((left, right) => left.localeCompare(right));
+}
+function readClaudeLocalState() {
+    const appSupportDir = node_path_1.default.join(node_os_1.default.homedir(), 'Library', 'Application Support', 'Claude');
+    const desktopConfig = readJsonFile(node_path_1.default.join(appSupportDir, 'claude_desktop_config.json'));
+    const gitWorktrees = readJsonFile(node_path_1.default.join(appSupportDir, 'git-worktrees.json'));
+    const preferences = desktopConfig && typeof desktopConfig === 'object'
+        ? desktopConfig.preferences
+        : null;
+    const trustedFolders = preferences && typeof preferences === 'object'
+        ? preferences.localAgentModeTrustedFolders
+        : null;
+    const trackedWorktreePaths = gitWorktrees && typeof gitWorktrees === 'object'
+        ? collectClaudeTrackedWorktreePaths(gitWorktrees.worktrees && typeof gitWorktrees.worktrees === 'object'
+            ? gitWorktrees.worktrees
+            : gitWorktrees)
+        : [];
+    return {
+        trustedFolders: Array.isArray(trustedFolders)
+            ? uniqueSortedStrings(trustedFolders.map((value) => typeof value === 'string' && value.startsWith('/') ? realpathSafe(value) : null))
+            : [],
+        trackedWorktreePaths,
+    };
+}
+function readProcessCwd(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return null;
+    const result = (0, node_child_process_1.spawnSync)('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn'], {
+        encoding: 'utf8',
+        timeout: 1000,
+    });
+    if (result.error || result.status !== 0) {
+        return null;
+    }
+    const pathLine = String(result.stdout || '')
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.startsWith('n'));
+    return trimOptional(pathLine ? pathLine.slice(1) : null);
+}
+function isPathWithinRuntimeRoot(repo, candidatePath) {
+    const normalizedCandidate = trimOptional(candidatePath);
+    if (!normalizedCandidate)
+        return false;
+    const repoRoot = realpathSafe(runtimeRoot(repo)).replace(/\\/g, '/').toLowerCase();
+    const candidate = realpathSafe(normalizedCandidate).replace(/\\/g, '/').toLowerCase();
+    return candidate === repoRoot || candidate.startsWith(`${repoRoot}/`);
+}
+function isPathInsideFolder(candidatePath, parentPath) {
+    const normalizedCandidate = trimOptional(candidatePath);
+    const normalizedParent = trimOptional(parentPath);
+    if (!normalizedCandidate || !normalizedParent)
+        return false;
+    const candidate = realpathSafe(normalizedCandidate).replace(/\\/g, '/').toLowerCase();
+    const parent = realpathSafe(normalizedParent).replace(/\\/g, '/').toLowerCase();
+    return candidate === parent || candidate.startsWith(`${parent}/`);
+}
+function classifyAntigravityRole(processName, command) {
+    const haystack = `${normalizeProcessText(processName)} ${normalizeProcessText(command)}`;
+    if (haystack.includes('language_server_macos_'))
+        return 'language_server';
+    if (haystack.includes('tsserver.js'))
+        return 'typescript_server';
+    if (haystack.includes('jsonservermain'))
+        return 'json_language_server';
+    if (haystack.includes('shipit'))
+        return 'updater';
+    if (haystack.includes('--type=gpu-process'))
+        return 'gpu_helper';
+    if (haystack.includes('--type=renderer'))
+        return 'renderer';
+    if (haystack.includes('--utility-sub-type=node.mojom.nodeservice'))
+        return 'node_helper';
+    if (haystack.includes('/electron'))
+        return 'desktop_shell';
+    return 'helper';
+}
+function extractAntigravityProcessDetails(processName, command) {
+    const role = classifyAntigravityRole(processName, command);
+    const details = {
+        adapter: 'antigravity_v1',
+        role,
+    };
+    const workspaceMarker = extractCommandFlagValue(command, '--workspace_id');
+    const extensionServerPort = extractCommandFlagNumber(command, '--extension_server_port');
+    const httpsServerPort = extractCommandFlagNumber(command, '--https_server_port');
+    const lspPort = extractCommandFlagNumber(command, '--lsp_port');
+    const cloudCodeEndpoint = extractCommandFlagValue(command, '--cloud_code_endpoint');
+    const appDataDir = extractCommandFlagValue(command, '--app_data_dir');
+    if (workspaceMarker)
+        details.workspaceMarker = workspaceMarker;
+    if (extensionServerPort !== null)
+        details.extensionServerPort = extensionServerPort;
+    if (httpsServerPort !== null)
+        details.httpsServerPort = httpsServerPort;
+    if (lspPort !== null)
+        details.lspPort = lspPort;
+    if (cloudCodeEndpoint)
+        details.cloudCodeEndpoint = cloudCodeEndpoint;
+    if (appDataDir)
+        details.appDataDir = appDataDir;
+    if (normalizeProcessText(command).includes('--enable_lsp')) {
+        details.enableLsp = true;
+    }
+    return details;
+}
+function isAntigravitySupportRole(role) {
+    return ['updater', 'gpu_helper', 'renderer', 'node_helper', 'helper']
+        .includes(String(role || '').trim().toLowerCase());
+}
+function classifyClaudeRole(processName, command) {
+    const haystack = `${normalizeProcessText(processName)} ${normalizeProcessText(command)}`;
+    if (haystack.includes('chrome-native-host') && haystack.includes('/applications/claude.app/'))
+        return 'browser_bridge';
+    if (haystack.includes('/applications/claude.app/contents/helpers/disclaimer'))
+        return 'sandbox_disclaimer';
+    if (normalizeProcessText(processName) === 'claude'
+        || haystack.includes(' claude ')
+        || haystack.includes('/claude ')
+        || haystack.endsWith('/claude'))
+        return 'cli_agent';
+    return 'helper';
+}
+function extractClaudeProcessDetails(processName, command, cwdPath, repo, claudeState) {
+    const role = classifyClaudeRole(processName, command);
+    const host = role === 'browser_bridge'
+        ? 'desktop_app'
+        : (role === 'cli_agent' ? 'cli' : null);
+    const extensionId = extractChromeExtensionId(command);
+    const trustedRuntimeRoot = claudeState
+        ? claudeState.trustedFolders.some((folder) => isPathInsideFolder(runtimeRoot(repo), folder))
+        : false;
+    const worktreeTracked = claudeState
+        ? claudeState.trackedWorktreePaths.some((trackedPath) => isPathInsideFolder(runtimeRoot(repo), trackedPath))
+        : false;
+    return {
+        adapter: 'claude_v1',
+        role,
+        ...(host ? { host } : {}),
+        ...(extensionId ? { extensionId } : {}),
+        ...(cwdPath ? { cwdPath } : {}),
+        ...(trustedRuntimeRoot ? { trustedRuntimeRoot: true } : {}),
+        ...(worktreeTracked ? { worktreeTracked: true } : {}),
+    };
+}
+function isClaudeSupportRole(role) {
+    return ['sandbox_disclaimer', 'helper'].includes(String(role || '').trim().toLowerCase());
+}
+function classifyCodexRole(processName, command) {
+    const haystack = `${normalizeProcessText(processName)} ${normalizeProcessText(command)}`;
+    if (haystack.includes('/.vscode/extensions/') && haystack.includes('codex app-server'))
+        return 'vscode_extension_server';
+    if (haystack.includes('--working-dir') || haystack.includes('/applications/codex.app/contents/resources/node'))
+        return 'desktop_kernel';
+    if (haystack.includes('/applications/codex.app/contents/macos/codex'))
+        return 'desktop_shell';
+    if (haystack.includes('--type=gpu-process'))
+        return 'gpu_helper';
+    if (haystack.includes('--type=renderer'))
+        return 'renderer';
+    if (haystack.includes('crashpad_handler'))
+        return 'crashpad_helper';
+    return 'helper';
+}
+function extractCodexProcessDetails(processName, command, cwdPath) {
+    const role = classifyCodexRole(processName, command);
+    const extensionId = extractVsCodeExtensionId(command);
+    const sessionId = extractCommandFlagValue(command, '--session-id');
+    const workingDir = extractCommandFlagValue(command, '--working-dir');
+    const host = extensionId
+        ? 'vscode_extension'
+        : (normalizeProcessText(command).includes('/applications/codex.app/')
+            ? 'desktop_app'
+            : null);
+    return {
+        adapter: 'codex_v1',
+        role,
+        ...(host ? { host } : {}),
+        ...(extensionId ? { extensionId } : {}),
+        ...(sessionId ? { sessionId } : {}),
+        ...(workingDir ? { workingDir } : {}),
+        ...(cwdPath ? { cwdPath } : {}),
+    };
+}
+function isCodexSupportRole(role) {
+    return ['gpu_helper', 'renderer', 'crashpad_helper', 'helper']
+        .includes(String(role || '').trim().toLowerCase());
+}
+function classifyVsCodeRole(processName, command) {
+    const haystack = `${normalizeProcessText(processName)} ${normalizeProcessText(command)}`;
+    if (haystack.includes('jsonservermain'))
+        return 'json_language_server';
+    if (haystack.includes('markdown-language-features') || haystack.includes('serverworkermain'))
+        return 'markdown_language_server';
+    if (haystack.includes('--type=gpu-process'))
+        return 'gpu_helper';
+    if (haystack.includes('--type=renderer'))
+        return 'renderer';
+    if (haystack.includes('--utility-sub-type=network.'))
+        return 'network_helper';
+    if (haystack.includes('--utility-sub-type=node.mojom.nodeservice'))
+        return 'plugin_host';
+    if (haystack.includes('/contents/macos/code'))
+        return 'editor_shell';
+    return 'helper';
+}
+function extractVsCodeProcessDetails(processName, command, cwdPath) {
+    const role = classifyVsCodeRole(processName, command);
+    return {
+        adapter: 'vscode_v1',
+        role,
+        ...(cwdPath ? { cwdPath } : {}),
+    };
+}
+function isVsCodeSupportRole(role) {
+    return ['gpu_helper', 'renderer', 'network_helper', 'helper']
+        .includes(String(role || '').trim().toLowerCase());
+}
+function classifyCursorRole(processName, command) {
+    const haystack = `${normalizeProcessText(processName)} ${normalizeProcessText(command)}`;
+    if (haystack.includes('cursoruiviewservice'))
+        return 'ui_service';
+    if (haystack.includes('--type=gpu-process'))
+        return 'gpu_helper';
+    if (haystack.includes('--type=renderer'))
+        return 'renderer';
+    if (haystack.includes('/contents/macos/cursor'))
+        return 'editor_shell';
+    return 'helper';
+}
+function extractCursorProcessDetails(processName, command, cwdPath) {
+    const role = classifyCursorRole(processName, command);
+    return {
+        adapter: 'cursor_v1',
+        role,
+        ...(cwdPath ? { cwdPath } : {}),
+    };
+}
+function isCursorSupportRole(role) {
+    return ['ui_service', 'gpu_helper', 'renderer', 'helper']
+        .includes(String(role || '').trim().toLowerCase());
+}
+function detectActiveRuntimeTooling(repo, processEntries, options = {}) {
+    const toolingByKey = new Map(TOOLING_DEFINITIONS.map((definition) => [definition.key, definition]));
+    const accumulators = new Map();
+    const cwdCache = new Map();
+    let claudeStateCache = options.claudeState;
+    let claudeStateLoaded = options.claudeState !== undefined;
+    for (const entry of processEntries) {
+        const processName = String(entry.name || '').trim();
+        const command = String(entry.cmd || '').trim();
+        if (!processName && !command)
+            continue;
+        const matchedKeys = new Map();
+        for (const definition of TOOLING_DEFINITIONS) {
+            if (matchesToolProcess(definition, processName, command)) {
+                matchedKeys.set(definition.key, new Set(['binary']));
+            }
+        }
+        const agentProcess = (0, process_scout_1.classifyAgentProcessEntry)(entry);
+        const mappedAgentKey = agentProcess ? AGENT_SIGNATURE_TO_TOOL_KEY[agentProcess.signature] : null;
+        if (mappedAgentKey) {
+            const detectedBy = matchedKeys.get(mappedAgentKey) ?? new Set();
+            detectedBy.add('agent_signature');
+            matchedKeys.set(mappedAgentKey, detectedBy);
+        }
+        if (matchedKeys.size === 0) {
+            continue;
+        }
+        const commandScoped = hasRepoScopeEvidence(repo, command);
+        const pid = Number(entry.pid || 0);
+        const cwdPath = cwdCache.has(pid)
+            ? cwdCache.get(pid) ?? null
+            : (() => {
+                const resolved = options.processCwdLookup ? options.processCwdLookup(pid) : readProcessCwd(pid);
+                cwdCache.set(pid, resolved);
+                return resolved;
+            })();
+        const cwdScoped = isPathWithinRuntimeRoot(repo, cwdPath);
+        const scoped = commandScoped || cwdScoped;
+        const genericHelperProcess = isLowSignalHelperProcess(processName, command);
+        const processExample = processName || command.split(/\s+/)[0] || 'unknown';
+        for (const [toolKey, detectedBy] of matchedKeys.entries()) {
+            const definition = toolingByKey.get(toolKey);
+            if (!definition)
+                continue;
+            const antigravityDetails = toolKey === 'antigravity'
+                ? extractAntigravityProcessDetails(processName, command)
+                : null;
+            if (toolKey === 'claude' && !claudeStateLoaded) {
+                claudeStateCache = readClaudeLocalState();
+                claudeStateLoaded = true;
+            }
+            const claudeDetails = toolKey === 'claude'
+                ? extractClaudeProcessDetails(processName, command, cwdPath, repo, claudeStateCache ?? null)
+                : null;
+            const codexDetails = toolKey === 'codex'
+                ? extractCodexProcessDetails(processName, command, cwdPath)
+                : null;
+            const vscodeDetails = toolKey === 'vscode'
+                ? extractVsCodeProcessDetails(processName, command, cwdPath)
+                : null;
+            const cursorDetails = toolKey === 'cursor'
+                ? extractCursorProcessDetails(processName, command, cwdPath)
+                : null;
+            const helperProcess = genericHelperProcess
+                || (toolKey === 'antigravity'
+                    && isAntigravitySupportRole(typeof antigravityDetails?.role === 'string' ? antigravityDetails.role : null))
+                || (toolKey === 'claude'
+                    && isClaudeSupportRole(typeof claudeDetails?.role === 'string' ? claudeDetails.role : null))
+                || (toolKey === 'codex'
+                    && isCodexSupportRole(typeof codexDetails?.role === 'string' ? codexDetails.role : null))
+                || (toolKey === 'vscode'
+                    && isVsCodeSupportRole(typeof vscodeDetails?.role === 'string' ? vscodeDetails.role : null))
+                || (toolKey === 'cursor'
+                    && isCursorSupportRole(typeof cursorDetails?.role === 'string' ? cursorDetails.role : null));
+            if (scoped) {
+                if (commandScoped)
+                    detectedBy.add('repo_scope');
+                if (cwdScoped)
+                    detectedBy.add('process_cwd');
+            }
+            const next = accumulators.get(toolKey) ?? {
+                label: definition.label,
+                processIds: new Set(),
+                activeIds: new Set(),
+                helperIds: new Set(),
+                scopedIds: new Set(),
+                ambientIds: new Set(),
+                scopedCpuPercentTotal: 0,
+                scopedCpuSamples: 0,
+                scopedMemoryMbTotal: 0,
+                scopedMemorySamples: 0,
+                detectedBy: new Set(),
+                exampleProcesses: [],
+                detailRecords: [],
+            };
+            next.processIds.add(pid);
+            if (helperProcess) {
+                next.helperIds.add(pid);
+            }
+            else {
+                next.activeIds.add(pid);
+            }
+            if (scoped) {
+                next.scopedIds.add(pid);
+                const scopedCpuPercent = cpuValue(entry.cpu);
+                if (scopedCpuPercent !== null) {
+                    next.scopedCpuPercentTotal += scopedCpuPercent;
+                    next.scopedCpuSamples += 1;
+                }
+                const scopedMemoryMb = bytesToMb(entry.memory);
+                if (scopedMemoryMb !== null) {
+                    next.scopedMemoryMbTotal += scopedMemoryMb;
+                    next.scopedMemorySamples += 1;
+                }
+            }
+            else {
+                next.ambientIds.add(pid);
+            }
+            for (const source of detectedBy) {
+                next.detectedBy.add(source);
+            }
+            if (!next.exampleProcesses.includes(processExample)) {
+                if (!helperProcess) {
+                    next.exampleProcesses.unshift(processExample);
+                }
+                else {
+                    next.exampleProcesses.push(processExample);
+                }
+                next.exampleProcesses = next.exampleProcesses.slice(0, 6);
+            }
+            if (toolKey === 'antigravity' && antigravityDetails)
+                next.detailRecords.push(antigravityDetails);
+            if (toolKey === 'claude' && claudeDetails)
+                next.detailRecords.push(claudeDetails);
+            if (toolKey === 'codex' && codexDetails)
+                next.detailRecords.push(codexDetails);
+            if (toolKey === 'vscode' && vscodeDetails)
+                next.detailRecords.push(vscodeDetails);
+            if (toolKey === 'cursor' && cursorDetails)
+                next.detailRecords.push(cursorDetails);
+            accumulators.set(toolKey, next);
+        }
+    }
+    return [...accumulators.entries()]
+        .map(([key, value]) => {
+        let details;
+        if (key === 'antigravity' && value.detailRecords.length > 0) {
+            const roles = uniqueSortedStrings(value.detailRecords.map((record) => String(record.role || '')));
+            const workspaceMarkers = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.workspaceMarker === 'string' ? record.workspaceMarker : null));
+            const extensionServerPorts = uniqueSortedNumbers(value.detailRecords.map((record) => typeof record.extensionServerPort === 'number' ? record.extensionServerPort : null));
+            const httpsServerPorts = uniqueSortedNumbers(value.detailRecords.map((record) => typeof record.httpsServerPort === 'number' ? record.httpsServerPort : null));
+            const lspPorts = uniqueSortedNumbers(value.detailRecords.map((record) => typeof record.lspPort === 'number' ? record.lspPort : null));
+            const cloudCodeEndpoints = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.cloudCodeEndpoint === 'string' ? record.cloudCodeEndpoint : null));
+            const appDataDirs = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.appDataDir === 'string' ? record.appDataDir : null));
+            details = {
+                adapter: 'antigravity_v1',
+                roles,
+                ...(roles[0] ? { primaryRole: roles.includes('language_server') ? 'language_server' : roles[0] } : {}),
+                ...(workspaceMarkers.length > 0 ? { workspaceMarkers } : {}),
+                ...(extensionServerPorts.length > 0 ? { extensionServerPorts } : {}),
+                ...(httpsServerPorts.length > 0 ? { httpsServerPorts } : {}),
+                ...(lspPorts.length > 0 ? { lspPorts } : {}),
+                ...(cloudCodeEndpoints.length > 0 ? { cloudCodeEndpoints } : {}),
+                ...(appDataDirs.length > 0 ? { appDataDirs } : {}),
+                enableLsp: value.detailRecords.some((record) => record.enableLsp === true),
+            };
+        }
+        if (key === 'claude' && value.detailRecords.length > 0) {
+            const roles = uniqueSortedStrings(value.detailRecords.map((record) => String(record.role || '')));
+            const hosts = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.host === 'string' ? record.host : null));
+            const extensionIds = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.extensionId === 'string' ? record.extensionId : null));
+            const cwdPaths = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.cwdPath === 'string' ? record.cwdPath : null));
+            const primaryRole = ['cli_agent', 'browser_bridge'].find((role) => roles.includes(role)) ?? roles[0] ?? null;
+            details = {
+                adapter: 'claude_v1',
+                roles,
+                ...(primaryRole ? { primaryRole } : {}),
+                ...(hosts.length > 0 ? { hosts } : {}),
+                ...(extensionIds.length > 0 ? { extensionIds } : {}),
+                ...(cwdPaths.length > 0 ? { cwdPaths } : {}),
+                trustedRuntimeRoot: value.detailRecords.some((record) => record.trustedRuntimeRoot === true),
+                worktreeTracked: value.detailRecords.some((record) => record.worktreeTracked === true),
+            };
+        }
+        if (key === 'codex' && value.detailRecords.length > 0) {
+            const roles = uniqueSortedStrings(value.detailRecords.map((record) => String(record.role || '')));
+            const hosts = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.host === 'string' ? record.host : null));
+            const extensionIds = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.extensionId === 'string' ? record.extensionId : null));
+            const sessionIds = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.sessionId === 'string' ? record.sessionId : null));
+            const workingDirs = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.workingDir === 'string' ? record.workingDir : null));
+            const cwdPaths = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.cwdPath === 'string' ? record.cwdPath : null));
+            const primaryRole = ['desktop_kernel', 'vscode_extension_server', 'desktop_shell'].find((role) => roles.includes(role)) ?? roles[0] ?? null;
+            details = {
+                adapter: 'codex_v1',
+                roles,
+                ...(primaryRole ? { primaryRole } : {}),
+                ...(hosts.length > 0 ? { hosts } : {}),
+                ...(extensionIds.length > 0 ? { extensionIds } : {}),
+                ...(sessionIds.length > 0 ? { sessionIds } : {}),
+                ...(workingDirs.length > 0 ? { workingDirs } : {}),
+                ...(cwdPaths.length > 0 ? { cwdPaths } : {}),
+            };
+        }
+        if ((key === 'vscode' || key === 'cursor') && value.detailRecords.length > 0) {
+            const roles = uniqueSortedStrings(value.detailRecords.map((record) => String(record.role || '')));
+            const cwdPaths = uniqueSortedStrings(value.detailRecords.map((record) => typeof record.cwdPath === 'string' ? record.cwdPath : null));
+            const adapter = key === 'vscode' ? 'vscode_v1' : 'cursor_v1';
+            const preferredRoles = key === 'vscode'
+                ? ['json_language_server', 'markdown_language_server', 'plugin_host', 'editor_shell']
+                : ['editor_shell', 'ui_service'];
+            const primaryRole = preferredRoles.find((role) => roles.includes(role)) ?? roles[0] ?? null;
+            details = {
+                adapter,
+                roles,
+                ...(primaryRole ? { primaryRole } : {}),
+                ...(cwdPaths.length > 0 ? { cwdPaths } : {}),
+            };
+        }
+        return {
+            key,
+            label: value.label,
+            processCount: value.processIds.size,
+            activeProcessCount: value.activeIds.size,
+            helperProcessCount: value.helperIds.size,
+            scopedProcessCount: value.scopedIds.size,
+            ambientProcessCount: value.ambientIds.size,
+            detectedBy: [...value.detectedBy.values()],
+            exampleProcesses: value.exampleProcesses.slice(0, 4),
+            scoped: value.scopedIds.size > 0,
+            ...(value.scopedCpuSamples > 0 ? { cpuPercent: roundMetric(value.scopedCpuPercentTotal) } : {}),
+            ...(value.scopedMemorySamples > 0 ? { memoryMb: roundMetric(value.scopedMemoryMbTotal) } : {}),
+            ...(details ? { details } : {}),
+        };
+    })
+        .sort((left, right) => {
+        if (left.scoped !== right.scoped)
+            return left.scoped ? -1 : 1;
+        return right.processCount - left.processCount;
+    });
+}
+function extractObservationWorkingFolders(repo, observation) {
+    const details = observation.details && typeof observation.details === 'object' && !Array.isArray(observation.details)
+        ? observation.details
+        : null;
+    const cwdPaths = Array.isArray(details?.cwdPaths) ? details.cwdPaths : [];
+    const workingDirs = Array.isArray(details?.workingDirs) ? details.workingDirs : [];
+    const folders = [...new Set([
+            ...cwdPaths.map((value) => normalizeRelativeToRuntime(repo, value)),
+            ...workingDirs.map((value) => normalizeRelativeToRuntime(repo, value)),
+        ].filter((value) => Boolean(value)))].sort((left, right) => {
+        if (left === '.')
+            return -1;
+        if (right === '.')
+            return 1;
+        return left.localeCompare(right);
+    });
+    return folders.length > 0
+        ? folders.slice(0, 6)
+        : [runtimeRelativeEntrypoint(repo)];
+}
+function extractObservedFolderLabels(repo, observations) {
+    return [...new Set(observations.flatMap((observation) => extractObservationWorkingFolders(repo, observation)))]
+        .slice(0, 6);
+}
+function extractObservedModelLabels(observations) {
+    return Array.from(new Set(observations.flatMap((observation) => {
+        const details = observation.details && typeof observation.details === 'object' && !Array.isArray(observation.details)
+            ? observation.details
+            : null;
+        if (!details)
+            return [];
+        const values = [
+            typeof details.model === 'string' ? details.model : null,
+            typeof details.modelName === 'string' ? details.modelName : null,
+            ...(Array.isArray(details.modelLabels) ? details.modelLabels : []),
+            ...(Array.isArray(details.models) ? details.models : []),
+        ];
+        return values
+            .filter((value) => typeof value === 'string' && value.trim().length > 0)
+            .map((value) => value.trim())
+            .filter((value) => value.toLowerCase() !== 'runtime-observer-v1');
+    }))).slice(0, 6);
+}
+function buildObservationReport(observation) {
+    const compactDetails = observation.details && typeof observation.details === 'object' && !Array.isArray(observation.details)
+        ? observation.details
+        : null;
+    const parts = [];
+    const primaryRole = typeof compactDetails?.primaryRole === 'string' ? compactDetails.primaryRole.trim() : '';
+    parts.push(`${observation.label}${primaryRole ? ` is active as ${primaryRole}` : ' is active'} in this runtime`);
+    parts.push(`${observation.activeProcessCount} active process${observation.activeProcessCount === 1 ? '' : 'es'} observed`);
+    if (observation.helperProcessCount > 0) {
+        parts.push(`${observation.helperProcessCount} helper process${observation.helperProcessCount === 1 ? '' : 'es'} also visible`);
+    }
+    if (observation.detectedBy.length > 0) {
+        parts.push(`scope evidence: ${observation.detectedBy.join(', ')}`);
+    }
+    const detailFragments = [
+        Array.isArray(compactDetails?.hosts) ? summarizeObservationList(compactDetails.hosts, 'hosts') : null,
+        Array.isArray(compactDetails?.extensionIds) ? summarizeObservationList(compactDetails.extensionIds, 'extensions') : null,
+        Array.isArray(compactDetails?.workspaceMarkers) ? summarizeObservationList(compactDetails.workspaceMarkers, 'workspace markers', 2) : null,
+        Array.isArray(compactDetails?.cwdPaths) ? summarizeObservationList(compactDetails.cwdPaths, 'cwd paths', 2) : null,
+        Array.isArray(compactDetails?.cloudCodeEndpoints) ? summarizeObservationList(compactDetails.cloudCodeEndpoints, 'cloud endpoints', 2) : null,
+        Array.isArray(compactDetails?.lspPorts) ? summarizeObservationList(compactDetails.lspPorts, 'LSP ports') : null,
+        Array.isArray(compactDetails?.extensionServerPorts) ? summarizeObservationList(compactDetails.extensionServerPorts, 'extension server ports') : null,
+        Array.isArray(compactDetails?.httpsServerPorts) ? summarizeObservationList(compactDetails.httpsServerPorts, 'HTTPS ports') : null,
+        compactDetails?.enableLsp === true ? 'LSP is enabled' : null,
+        compactDetails?.trustedRuntimeRoot === true ? 'runtime root is trusted locally' : null,
+        compactDetails?.worktreeTracked === true ? 'worktree is tracked locally' : null,
+    ].filter((value) => Boolean(value));
+    if (detailFragments.length > 0) {
+        parts.push(detailFragments.join('; '));
+    }
+    const resourceParts = [];
+    if (typeof observation.cpuPercent === 'number' && Number.isFinite(observation.cpuPercent)) {
+        resourceParts.push(`CPU ${roundMetric(observation.cpuPercent)}%`);
+    }
+    if (typeof observation.memoryMb === 'number' && Number.isFinite(observation.memoryMb)) {
+        resourceParts.push(`memory ${roundMetric(observation.memoryMb)} MB`);
+    }
+    if (resourceParts.length > 0) {
+        parts.push(resourceParts.join(' · '));
+    }
+    return `${parts.join('. ')}.`;
+}
+function slugifyRuntimeLabel(value, maxLength = 80) {
+    const normalized = value
+        .trim()
+        .replace(/[\\/]+/g, '-')
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return (normalized || 'runtime').slice(0, maxLength);
+}
+function buildRuntimeObservationSteps(runId, observations, options = {}) {
+    const parentRunId = trimOptional(runId);
+    if (!parentRunId) {
+        throw new Error('Run id is required to build runtime observation steps.');
+    }
+    const observedAt = trimOptional(options.observedAt) ?? new Date().toISOString();
+    const provider = trimOptional(options.provider) ?? 'forkit-connect';
+    const model = trimOptional(options.model) ?? 'runtime-observer-v1';
+    return observations.map((observation, index) => {
+        const summary = buildObservationReport(observation);
+        const details = observation.details && typeof observation.details === 'object' && !Array.isArray(observation.details)
+            ? observation.details
+            : undefined;
+        return {
+            stepId: `${parentRunId}:observe:${slugifyRuntimeLabel(observation.key, 32)}:${index + 1}`,
+            parentRunId,
+            sequence: index,
+            stepKind: 'custom',
+            title: `${observation.label} activity observed`,
+            status: 'completed',
+            provider,
+            model,
+            startedAt: observedAt,
+            endedAt: observedAt,
+            summary,
+            toolCalls: [],
+            metadata: {
+                actor: {
+                    key: observation.key,
+                    label: observation.label,
+                    scoped: observation.scoped,
+                    processCount: observation.processCount,
+                    activeProcessCount: observation.activeProcessCount,
+                    helperProcessCount: observation.helperProcessCount,
+                    scopedProcessCount: observation.scopedProcessCount,
+                    ambientProcessCount: observation.ambientProcessCount,
+                    detectedBy: observation.detectedBy,
+                    exampleProcesses: observation.exampleProcesses.slice(0, 4),
+                    ...(details ? { details } : {}),
+                },
+                report: summary,
+            },
+        };
+    });
+}
+//# sourceMappingURL=runtime-observer.js.map