forkit-connect 0.1.0

package/dist/v1/vitality-pulse.js

@@ -0,0 +1,512 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkEndpointPortAlive = checkEndpointPortAlive;
+exports.probeGpuHealth = probeGpuHealth;
+exports.classifyPulseStatus = classifyPulseStatus;
+exports.collectVitalityPulse = collectVitalityPulse;
+exports.buildPulseEvents = buildPulseEvents;
+const node_child_process_1 = require("node:child_process");
+const node_net_1 = __importDefault(require("node:net"));
+const node_util_1 = require("node:util");
+const ps_list_loader_1 = require("../ps-list-loader");
+const discovery_1 = require("./discovery");
+const ollama_1 = require("./ollama");
+const process_scout_1 = require("./process-scout");
+const process_scout_2 = require("./process-scout");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function nowIso() {
+    return new Date().toISOString();
+}
+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 parseEndpointPort(endpoint) {
+    try {
+        const url = new URL(endpoint);
+        const port = Number(url.port || (url.protocol === 'https:' ? 443 : 80));
+        if (!Number.isFinite(port) || port <= 0)
+            return null;
+        return {
+            host: url.hostname,
+            port,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function parseElapsedRuntimeSeconds(value) {
+    const raw = String(value || '').trim();
+    if (!raw)
+        return null;
+    const normalized = raw.replace(/\s+/g, '');
+    const [dayPart, clockPart] = normalized.includes('-')
+        ? normalized.split('-', 2)
+        : [null, normalized];
+    const dayCount = dayPart === null ? 0 : Number(dayPart);
+    if (!Number.isFinite(dayCount) || dayCount < 0)
+        return null;
+    const clockSegments = clockPart.split(':').map((segment) => Number(segment));
+    if (clockSegments.some((segment) => !Number.isFinite(segment) || segment < 0)) {
+        return null;
+    }
+    if (clockSegments.length === 2) {
+        const minutes = clockSegments[0] ?? 0;
+        const seconds = clockSegments[1] ?? 0;
+        return Math.round((dayCount * 24 * 60 * 60) + (minutes * 60) + seconds);
+    }
+    if (clockSegments.length === 3) {
+        const hours = clockSegments[0] ?? 0;
+        const minutes = clockSegments[1] ?? 0;
+        const seconds = clockSegments[2] ?? 0;
+        return Math.round((dayCount * 24 * 60 * 60) + (hours * 60 * 60) + (minutes * 60) + seconds);
+    }
+    return null;
+}
+async function probeProcessElapsedSeconds(pid) {
+    try {
+        const { stdout } = await execFileAsync('ps', ['-o', 'etime=', '-p', String(pid)]);
+        const firstLine = String(stdout || '').split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+        return firstLine ? parseElapsedRuntimeSeconds(firstLine) : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function checkEndpointPortHealth(endpoint, timeoutMs = 1500) {
+    const startedAt = Date.now();
+    const alive = await checkEndpointPortAlive(endpoint, timeoutMs);
+    const latencyMs = alive ? roundMetric(Date.now() - startedAt) : null;
+    return { alive, latencyMs };
+}
+function metricAvailability(available, note, source) {
+    return {
+        available,
+        note,
+        source,
+    };
+}
+function isInventoryOnlyRuntime(runtime) {
+    return runtime.runtimeType === 'local-filesystem';
+}
+function buildMetricAvailability(input) {
+    const processMissingNote = 'Local process metrics are unavailable because Connect could not safely match a runtime process this cycle.';
+    const processPartialNote = 'Local process visibility is limited right now, so this metric was not exposed by the operating system sample.';
+    const latencyMissingNote = input.portAlive
+        ? 'Latency probe ran without a stable round-trip measurement this cycle.'
+        : 'Latency is unavailable because the local runtime endpoint did not accept a probe connection.';
+    const gpuMissingNote = input.gpuAvailable
+        ? 'GPU probe responded, but utilization details were not exposed this cycle.'
+        : 'GPU metrics are unavailable because no supported local GPU probe responded.';
+    if (input.inventoryOnly) {
+        const inventoryOnlyNote = 'Metrics are unavailable because this source is inventory-only local model discovery, not a live runtime endpoint.';
+        return {
+            cpu_usage_percent: metricAvailability(false, inventoryOnlyNote, 'inventory_scan'),
+            memory_usage_mb: metricAvailability(false, inventoryOnlyNote, 'inventory_scan'),
+            uptime_seconds: metricAvailability(false, inventoryOnlyNote, 'inventory_scan'),
+            runtime_latency_ms: metricAvailability(false, inventoryOnlyNote, 'inventory_scan'),
+            token_metrics: metricAvailability(false, 'Token metrics stay unavailable in metadata-only observation mode because Connect does not inspect prompts or responses.', 'privacy_boundary'),
+            gpu_utilization_percent: metricAvailability(false, inventoryOnlyNote, 'inventory_scan'),
+            gpu_vram_used_mb: metricAvailability(false, inventoryOnlyNote, 'inventory_scan'),
+        };
+    }
+    return {
+        cpu_usage_percent: input.processMatched
+            ? input.cpuUsagePercent !== null
+                ? metricAvailability(true, 'Captured from the local process CPU sample.', 'process_list')
+                : metricAvailability(false, processPartialNote, 'process_list')
+            : metricAvailability(false, processMissingNote, 'process_match'),
+        memory_usage_mb: input.processMatched
+            ? input.memoryUsageMb !== null
+                ? metricAvailability(true, 'Captured from the local process memory sample.', 'process_list')
+                : metricAvailability(false, processPartialNote, 'process_list')
+            : metricAvailability(false, processMissingNote, 'process_match'),
+        uptime_seconds: input.processMatched
+            ? input.uptimeSeconds !== null
+                ? metricAvailability(true, 'Captured from operating-system elapsed process time.', 'process_elapsed')
+                : metricAvailability(false, 'Runtime uptime is unavailable because the operating system did not expose elapsed process time.', 'process_elapsed')
+            : metricAvailability(false, processMissingNote, 'process_match'),
+        runtime_latency_ms: input.portAlive && input.runtimeLatencyMs !== null
+            ? metricAvailability(true, 'Captured from the local TCP connect probe.', 'tcp_probe')
+            : metricAvailability(false, latencyMissingNote, 'tcp_probe'),
+        token_metrics: metricAvailability(false, 'Token metrics stay unavailable in metadata-only observation mode because Connect does not inspect prompts or responses.', 'privacy_boundary'),
+        gpu_utilization_percent: input.gpuAvailable && input.gpuUtilizationPercent !== null
+            ? metricAvailability(true, 'Captured from the supported local GPU probe.', 'gpu_probe')
+            : metricAvailability(false, gpuMissingNote, input.gpuAvailable ? 'gpu_probe' : 'gpu_probe_unavailable'),
+        gpu_vram_used_mb: input.gpuAvailable && input.gpuVramUsedMb !== null
+            ? metricAvailability(true, 'Captured from the supported local GPU probe.', 'gpu_probe')
+            : metricAvailability(false, gpuMissingNote, input.gpuAvailable ? 'gpu_probe' : 'gpu_probe_unavailable'),
+    };
+}
+function buildDegradedObservation(input) {
+    if (input.inventoryOnly) {
+        return {
+            degradedMode: 'normal',
+            degradedReasons: [],
+        };
+    }
+    if (input.providerStatus === 'unavailable' || input.providerStatus === 'error' || input.portAlive === false) {
+        return {
+            degradedMode: 'provider_unavailable',
+            degradedReasons: ['The local runtime endpoint did not respond to the observation probe.'],
+        };
+    }
+    const reasons = [];
+    if (!input.processMatched) {
+        reasons.push('Connect could not safely match a local runtime process, so CPU, memory, and uptime are partial.');
+    }
+    else {
+        if (input.cpuUsagePercent === null || input.memoryUsageMb === null) {
+            reasons.push('The operating-system process sample did not expose full CPU and memory metrics this cycle.');
+        }
+        if (input.uptimeSeconds === null) {
+            reasons.push('The operating system did not expose elapsed runtime uptime for this process.');
+        }
+    }
+    if (input.runtimeLatencyMs === null) {
+        reasons.push('The local latency probe did not produce a stable runtime round-trip measurement.');
+    }
+    return {
+        degradedMode: reasons.length > 0 ? 'partial_metrics' : 'normal',
+        degradedReasons: reasons,
+    };
+}
+function overallDegradedObservation(entries) {
+    if (entries.some((entry) => entry.degraded_mode === 'provider_unavailable')) {
+        return {
+            degradedMode: 'provider_unavailable',
+            degradedReasons: [...new Set(entries.flatMap((entry) => entry.degraded_reasons ?? []).filter(Boolean))],
+        };
+    }
+    if (entries.some((entry) => entry.degraded_mode === 'partial_metrics')) {
+        return {
+            degradedMode: 'partial_metrics',
+            degradedReasons: [...new Set(entries.flatMap((entry) => entry.degraded_reasons ?? []).filter(Boolean))],
+        };
+    }
+    return {
+        degradedMode: 'normal',
+        degradedReasons: [],
+    };
+}
+async function checkEndpointPortAlive(endpoint, timeoutMs = 1500) {
+    const target = parseEndpointPort(endpoint);
+    if (!target)
+        return false;
+    return await new Promise((resolve) => {
+        const socket = new node_net_1.default.Socket();
+        let resolved = false;
+        const finish = (value) => {
+            if (resolved)
+                return;
+            resolved = true;
+            socket.destroy();
+            resolve(value);
+        };
+        socket.setTimeout(timeoutMs);
+        socket.once('connect', () => finish(true));
+        socket.once('timeout', () => finish(false));
+        socket.once('error', () => finish(false));
+        socket.connect(target.port, target.host);
+    });
+}
+async function probeGpuHealth() {
+    try {
+        const { stdout } = await execFileAsync('nvidia-smi', [
+            '--query-gpu=utilization.gpu,memory.used',
+            '--format=csv,noheader,nounits',
+        ]);
+        const firstLine = String(stdout || '').split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+        if (!firstLine) {
+            return { gpu_available: true, gpu_vram_used_mb: null, gpu_utilization_percent: null };
+        }
+        const [utilizationRaw, memoryRaw] = firstLine.split(',').map((item) => item.trim());
+        const gpuUtilizationPercent = roundMetric(Number(utilizationRaw));
+        const gpuVramUsedMb = roundMetric(Number(memoryRaw));
+        return {
+            gpu_available: true,
+            gpu_vram_used_mb: Number.isFinite(Number(memoryRaw)) ? gpuVramUsedMb : null,
+            gpu_utilization_percent: Number.isFinite(Number(utilizationRaw)) ? gpuUtilizationPercent : null,
+        };
+    }
+    catch {
+        return {
+            gpu_available: false,
+            gpu_vram_used_mb: null,
+            gpu_utilization_percent: null,
+        };
+    }
+}
+function classifyPulseStatus(input) {
+    if (input.inventoryOnly) {
+        return 'unknown';
+    }
+    const reachable = input.providerStatus === 'detected' || input.portAlive === true;
+    const previouslyKnownNowUnreachable = input.knownRuntime
+        && input.portAlive === false
+        && input.processAlive === false
+        && input.providerStatus !== 'detected';
+    if (previouslyKnownNowUnreachable) {
+        return 'red';
+    }
+    if (!reachable) {
+        return 'unknown';
+    }
+    const highPressure = (input.cpuUsagePercent !== null && input.cpuUsagePercent >= 85)
+        || (input.memoryUsageMb !== null && input.memoryUsageMb >= 4096)
+        || (input.gpuUtilizationPercent !== null && input.gpuUtilizationPercent >= 90)
+        || (input.gpuVramUsedMb !== null && input.gpuVramUsedMb >= 16384);
+    const partialMetrics = input.processAlive !== true
+        || input.cpuUsagePercent === null
+        || input.memoryUsageMb === null
+        || (input.gpuAvailable && (input.gpuUtilizationPercent === null || input.gpuVramUsedMb === null));
+    if (highPressure || partialMetrics) {
+        return 'amber';
+    }
+    return 'green';
+}
+function processByPid(processes) {
+    return new Map(processes.map((entry) => [entry.pid, entry]));
+}
+function findProcessForRuntime(runtime, processScoutResults) {
+    return processScoutResults.find((entry) => (0, process_scout_2.matchesRuntimeObservation)(entry, runtime.runtimeName, runtime.endpoint)) ?? null;
+}
+function findModelForRuntime(state, runtime) {
+    return state.detected_models.find((model) => model.runtime === runtime.runtime && model.status !== 'ignored') ?? null;
+}
+function findRuntimePassportForRuntime(state, runtime) {
+    return state.runtime_passports.find((runtimePassport) => runtimePassport.discoveryHash === runtime.discoveryHash)
+        ?? state.runtime_passports.find((runtimePassport) => runtimePassport.runtime_name === runtime.runtimeName && runtimePassport.runtime_type === runtime.runtimeType);
+}
+function findBindingForModel(state, model, runtimeIdentity) {
+    if (!model)
+        return null;
+    const registrationKey = (0, discovery_1.buildModelRegistrationKey)(model, runtimeIdentity);
+    return state.model_bindings.find((item) => item.modelKey === (0, ollama_1.modelKey)(model)
+        || item.discoveryHash === model.discoveryHash
+        || item.registrationKey === registrationKey) ?? null;
+}
+function registrationStateForModel(state, model, runtimeIdentity) {
+    if (!model) {
+        return {
+            registrationState: 'unknown',
+            registrationKey: null,
+            boundPassportGaid: null,
+            bindingStatus: null,
+        };
+    }
+    const registrationKey = (0, discovery_1.buildModelRegistrationKey)(model, runtimeIdentity);
+    const binding = findBindingForModel(state, model, runtimeIdentity);
+    if (!binding) {
+        return {
+            registrationState: 'unregistered',
+            registrationKey,
+            boundPassportGaid: null,
+            bindingStatus: null,
+        };
+    }
+    return {
+        registrationState: binding.status === 'bound' ? 'registered' : 'unregistered',
+        registrationKey: binding.registrationKey ?? registrationKey,
+        boundPassportGaid: binding.gaid ?? null,
+        bindingStatus: binding.status,
+    };
+}
+function connectionClassificationForPulse(input) {
+    if (input.bindingStatus === 'bound') {
+        return 'registered_runtime';
+    }
+    if (input.providerStatus === 'unavailable' || input.providerStatus === 'error') {
+        return 'provider_unavailable';
+    }
+    if (input.model) {
+        return 'known_unregistered';
+    }
+    return null;
+}
+function providerStatusForRuntime(runtime, portAlive) {
+    if (isInventoryOnlyRuntime(runtime)) {
+        return runtime.status === 'error' ? 'error' : 'detected';
+    }
+    if (runtime.status === 'error')
+        return portAlive ? 'detected' : 'error';
+    if (runtime.status === 'detected' || runtime.status === 'connected')
+        return portAlive ? 'detected' : 'unavailable';
+    return portAlive ? 'detected' : 'unknown';
+}
+function overallPulseStatus(entries) {
+    if (entries.some((entry) => entry.pulse_status === 'red'))
+        return 'red';
+    if (entries.some((entry) => entry.pulse_status === 'amber'))
+        return 'amber';
+    if (entries.some((entry) => entry.pulse_status === 'green'))
+        return 'green';
+    return 'unknown';
+}
+async function collectVitalityPulse(state, dependencies) {
+    const measuredAt = dependencies?.measuredAt ?? nowIso();
+    const processScoutResults = dependencies?.processScoutResults ?? await (0, process_scout_1.scanLikelyAiProcesses)();
+    const processes = dependencies?.processList ? await dependencies.processList() : await (0, ps_list_loader_1.listProcesses)();
+    const processesByPid = processByPid(processes);
+    const gpu = dependencies?.gpuProbe ? await dependencies.gpuProbe() : await probeGpuHealth();
+    const runtimes = state.detected_runtimes;
+    const entries = await Promise.all(runtimes.map(async (runtime) => {
+        const inventoryOnly = isInventoryOnlyRuntime(runtime);
+        const matchedProcess = findProcessForRuntime(runtime, processScoutResults);
+        const rawProcess = matchedProcess ? processesByPid.get(matchedProcess.pid) ?? null : null;
+        const endpointHealth = inventoryOnly
+            ? { alive: null, latencyMs: null }
+            : dependencies?.portChecker
+                ? await (async () => {
+                    const startedAt = Date.now();
+                    const alive = await dependencies.portChecker?.(runtime.endpoint);
+                    return {
+                        alive: Boolean(alive),
+                        latencyMs: alive ? roundMetric(Date.now() - startedAt) : null,
+                    };
+                })()
+                : await checkEndpointPortHealth(runtime.endpoint);
+        const portAlive = endpointHealth.alive;
+        const processAlive = inventoryOnly ? null : matchedProcess ? Boolean(rawProcess || matchedProcess.pid > 0) : false;
+        const model = findModelForRuntime(state, runtime);
+        const runtimePassport = findRuntimePassportForRuntime(state, runtime);
+        const registration = registrationStateForModel(state, model, state.runtime_identity.runtimeId);
+        const providerStatus = providerStatusForRuntime(runtime, portAlive);
+        const cpuUsagePercent = inventoryOnly ? null : rawProcess ? cpuValue(rawProcess.cpu) : null;
+        const memoryUsageMb = inventoryOnly ? null : rawProcess ? bytesToMb(rawProcess.memory) : null;
+        const uptimeSeconds = inventoryOnly
+            ? null
+            : matchedProcess
+                ? (dependencies?.processUptimeProbe
+                    ? await dependencies.processUptimeProbe(matchedProcess.pid)
+                    : await probeProcessElapsedSeconds(matchedProcess.pid))
+                : null;
+        const metricAvailability = buildMetricAvailability({
+            inventoryOnly,
+            processMatched: Boolean(matchedProcess),
+            cpuUsagePercent,
+            memoryUsageMb,
+            uptimeSeconds,
+            runtimeLatencyMs: endpointHealth.latencyMs,
+            portAlive,
+            gpuAvailable: gpu.gpu_available,
+            gpuUtilizationPercent: gpu.gpu_utilization_percent,
+            gpuVramUsedMb: gpu.gpu_vram_used_mb,
+        });
+        const degradedObservation = buildDegradedObservation({
+            inventoryOnly,
+            providerStatus,
+            processMatched: Boolean(matchedProcess),
+            cpuUsagePercent,
+            memoryUsageMb,
+            uptimeSeconds,
+            runtimeLatencyMs: endpointHealth.latencyMs,
+            portAlive,
+        });
+        const pulseStatus = classifyPulseStatus({
+            inventoryOnly,
+            knownRuntime: true,
+            providerStatus,
+            portAlive,
+            processAlive,
+            cpuUsagePercent,
+            memoryUsageMb,
+            gpuAvailable: gpu.gpu_available,
+            gpuUtilizationPercent: gpu.gpu_utilization_percent,
+            gpuVramUsedMb: gpu.gpu_vram_used_mb,
+        });
+        return {
+            measured_at: measuredAt,
+            runtime_gaid: runtimePassport?.runtime_gaid ?? null,
+            runtime_name: runtime.runtimeName,
+            runtime_type: runtime.runtimeType,
+            model_name: model?.model ?? null,
+            discovery_hash: model?.discoveryHash ?? runtime.discoveryHash ?? null,
+            registration_key: registration.registrationKey,
+            bound_passport_gaid: registration.boundPassportGaid,
+            binding_status: registration.bindingStatus,
+            connection_classification: connectionClassificationForPulse({
+                model,
+                bindingStatus: registration.bindingStatus,
+                providerStatus,
+            }),
+            provider_status: providerStatus,
+            registration_state: registration.registrationState,
+            port_alive: portAlive,
+            process_alive: inventoryOnly ? null : matchedProcess ? processAlive : false,
+            cpu_usage_percent: cpuUsagePercent,
+            memory_usage_mb: memoryUsageMb,
+            uptime_seconds: uptimeSeconds,
+            runtime_latency_ms: endpointHealth.latencyMs,
+            gpu_available: gpu.gpu_available,
+            gpu_vram_used_mb: gpu.gpu_vram_used_mb,
+            gpu_utilization_percent: gpu.gpu_utilization_percent,
+            observation_mode: 'metadata_only',
+            degraded_mode: degradedObservation.degradedMode,
+            degraded_reasons: degradedObservation.degradedReasons,
+            metric_availability: metricAvailability,
+            pulse_status: pulseStatus,
+        };
+    }));
+    const overallDegraded = overallDegradedObservation(entries);
+    return {
+        measured_at: measuredAt,
+        pulse_status: overallPulseStatus(entries),
+        observation_mode: 'metadata_only',
+        degraded_mode: overallDegraded.degradedMode,
+        degraded_reasons: overallDegraded.degradedReasons,
+        entries,
+        green_count: entries.filter((entry) => entry.pulse_status === 'green').length,
+        amber_count: entries.filter((entry) => entry.pulse_status === 'amber').length,
+        red_count: entries.filter((entry) => entry.pulse_status === 'red').length,
+        unknown_count: entries.filter((entry) => entry.pulse_status === 'unknown').length,
+    };
+}
+function buildPulseEvents(summary) {
+    return summary.entries.map((entry) => ({
+        measured_at: entry.measured_at,
+        runtime_gaid: entry.runtime_gaid ?? null,
+        runtime_name: entry.runtime_name,
+        runtime_type: entry.runtime_type,
+        model_name: entry.model_name,
+        discovery_hash: entry.discovery_hash,
+        registration_key: entry.registration_key,
+        bound_passport_gaid: entry.bound_passport_gaid,
+        binding_status: entry.binding_status,
+        connection_classification: entry.connection_classification,
+        provider_status: entry.provider_status,
+        registration_state: entry.registration_state,
+        port_alive: entry.port_alive,
+        process_alive: entry.process_alive,
+        cpu_usage_percent: entry.cpu_usage_percent,
+        memory_usage_mb: entry.memory_usage_mb,
+        uptime_seconds: entry.uptime_seconds ?? null,
+        runtime_latency_ms: entry.runtime_latency_ms ?? null,
+        gpu_available: entry.gpu_available,
+        gpu_vram_used_mb: entry.gpu_vram_used_mb,
+        gpu_utilization_percent: entry.gpu_utilization_percent,
+        observation_mode: entry.observation_mode ?? 'metadata_only',
+        degraded_mode: entry.degraded_mode ?? 'normal',
+        degraded_reasons: entry.degraded_reasons ?? [],
+        ...(entry.metric_availability ? { metric_availability: entry.metric_availability } : {}),
+        pulse_status: entry.pulse_status,
+    }));
+}
+//# sourceMappingURL=vitality-pulse.js.map

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "forkit-connect",
+  "version": "0.1.0",
+  "description": "Forkit Connect Local Engine - The Global AI Governance Fabric",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "QUICKSTART.md"
+  ],
+  "scripts": {
+    "build": "pnpm run clean && tsc -p tsconfig.build.json",
+    "dev": "tsc -w -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "prepack": "pnpm run build && node ./scripts/prune-package-dist.js",
+    "install:ubuntu": "bash ./scripts/install-ubuntu-local.sh",
+    "smoke:package": "bash ./scripts/smoke-package.sh",
+    "desktop:dev": "pnpm run build && node dist/launcher.js",
+    "desktop:build": "pnpm run build && node dist/launcher.js --build-shell",
+    "deploy:local": "bash scripts/deploy-local.sh"
+  },
+  "bin": {
+    "forkit-connect": "./dist/cli.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.1",
+    "better-sqlite3": "^11.10.0",
+    "cors": "^2.8.6",
+    "express": "^4.19.2",
+    "keytar": "^7.9.0",
+    "ps-list": "^8.1.1",
+    "uuid": "^10.0.0",
+    "ws": "^8.16.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.0.0",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.5.10",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}