forkit-connect 0.1.0

package/dist/v1/ollama.d.ts

@@ -0,0 +1,19 @@
+import type { DetectedModel } from './types';
+import { type RuntimeProvider, type RuntimeProviderScanResult } from './providers';
+export interface OllamaScanResult {
+    ok: boolean;
+    endpoint: string;
+    models: DetectedModel[];
+    error: string | null;
+}
+export declare function scanOllama(endpoint?: string): Promise<OllamaScanResult>;
+export declare function modelKey(model: DetectedModel): string;
+export declare class OllamaProvider implements RuntimeProvider {
+    readonly endpoint: string;
+    private readonly fetchImpl;
+    readonly runtimeName = "ollama";
+    readonly runtimeType: "local-http";
+    constructor(endpoint?: string, fetchImpl?: typeof fetch);
+    scan(): Promise<RuntimeProviderScanResult>;
+}
+//# sourceMappingURL=ollama.d.ts.map

package/dist/v1/ollama.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaProvider = void 0;
+exports.scanOllama = scanOllama;
+exports.modelKey = modelKey;
+const providers_1 = require("./providers");
+/** Extract a bare sha256 hex string from Ollama's digest field ("sha256:abc..."). */
+function parseOllamaSha256(digest) {
+    const m = /^sha256:([0-9a-f]{64})$/i.exec(digest.trim());
+    return m ? m[1] : null;
+}
+/** Fetch enriched metadata for a single Ollama model via /api/show (best-effort, non-blocking). */
+async function fetchOllamaModelDetails(endpoint, modelName, fetchImpl) {
+    try {
+        const ac = new AbortController();
+        const timer = setTimeout(() => ac.abort(), 4000);
+        const res = await fetchImpl(`${endpoint}/api/show`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ model: modelName, verbose: false }),
+            signal: ac.signal,
+        }).finally(() => clearTimeout(timer));
+        if (!res.ok)
+            return { details: null, digest: null, weightsDigest: null };
+        const body = (await res.json());
+        // The layer with mediaType 'application/vnd.ollama.image.model' holds the
+        // actual weights blob SHA-256 — a stable, content-addressed fingerprint.
+        const modelLayer = body.layers?.find((l) => l.mediaType === 'application/vnd.ollama.image.model');
+        return {
+            details: body.details ?? null,
+            digest: body.digest ?? null,
+            weightsDigest: modelLayer?.digest ?? null,
+        };
+    }
+    catch {
+        return { details: null, digest: null, weightsDigest: null };
+    }
+}
+function normalizeModelKey(modelName, digest) {
+    return `${modelName}#${digest}`;
+}
+async function scanOllama(endpoint = 'http://localhost:11434') {
+    const result = await new OllamaProvider(endpoint).scan();
+    return {
+        ok: result.ok,
+        endpoint,
+        models: result.models,
+        error: result.error,
+    };
+}
+function modelKey(model) {
+    return `${model.model}#${model.digest}`;
+}
+class OllamaProvider {
+    endpoint;
+    fetchImpl;
+    runtimeName = 'ollama';
+    runtimeType = 'local-http';
+    constructor(endpoint = 'http://localhost:11434', fetchImpl = fetch) {
+        this.endpoint = endpoint;
+        this.fetchImpl = fetchImpl;
+    }
+    async scan() {
+        const tagsEndpoint = `${this.endpoint}/api/tags`;
+        const now = new Date().toISOString();
+        try {
+            const res = await this.fetchImpl(tagsEndpoint, { method: 'GET' });
+            if (!res.ok) {
+                return {
+                    ok: false,
+                    runtime: (0, providers_1.buildDetectedRuntime)({
+                        runtimeName: this.runtimeName,
+                        runtimeType: this.runtimeType,
+                        endpoint: this.endpoint,
+                        status: 'error',
+                        lastSeenAt: now,
+                        error: `http_${res.status}`,
+                    }),
+                    models: [],
+                    error: `http_${res.status}`,
+                };
+            }
+            const body = (await res.json());
+            const entries = body.models ?? [];
+            // Fetch enriched details for all models in parallel (non-blocking, best-effort).
+            const detailResults = await Promise.allSettled(entries.map((entry) => {
+                const name = (entry.name ?? entry.model ?? '').trim();
+                return name
+                    ? fetchOllamaModelDetails(this.endpoint, name, this.fetchImpl)
+                    : Promise.resolve({ details: null, digest: null, weightsDigest: null });
+            }));
+            const models = entries
+                .map((entry, i) => {
+                const name = (entry.name ?? entry.model ?? '').trim();
+                const rawDigest = (entry.digest ?? '').trim();
+                if (!name || !rawDigest)
+                    return null;
+                const showResult = detailResults[i]?.status === 'fulfilled'
+                    ? detailResults[i].value
+                    : { details: null, digest: null, weightsDigest: null };
+                // Prefer the weights-blob digest from /api/show for a content-addressed fingerprint.
+                // Fall back to the manifest digest from /api/tags for older Ollama versions.
+                const weightsDigestRaw = showResult?.weightsDigest ?? null;
+                const weightsChecksumHex = weightsDigestRaw ? parseOllamaSha256(weightsDigestRaw) : null;
+                const manifestChecksumHex = parseOllamaSha256(rawDigest);
+                const checksumHex = weightsChecksumHex ?? manifestChecksumHex;
+                const checksumSource = weightsChecksumHex ? 'weights_blob' : (manifestChecksumHex ? 'manifest' : null);
+                const details = showResult?.details ?? null;
+                return (0, providers_1.normalizeDetectedModel)({
+                    runtimeName: this.runtimeName,
+                    runtimeType: this.runtimeType,
+                    modelName: name,
+                    modelId: name,
+                    sourceEndpoint: this.endpoint,
+                    detectedAt: now,
+                    digest: rawDigest,
+                    sizeBytes: Number(entry.size ?? 0),
+                    modifiedAt: entry.modified_at ?? null,
+                    checksumValue: checksumHex,
+                    checksumAlgorithm: checksumHex ? 'sha256' : null,
+                    checksumSource,
+                    quantizationLevel: details?.quantization_level ?? null,
+                    architectureFamily: details?.family ?? null,
+                    parameterSize: details?.parameter_size ?? null,
+                    metadata: {
+                        normalized_model_key: normalizeModelKey(name, rawDigest),
+                        ...(details?.format ? { format: details.format } : {}),
+                        ...(details?.families?.length ? { families: details.families } : {}),
+                    },
+                });
+            })
+                .filter((item) => Boolean(item));
+            return {
+                ok: true,
+                runtime: (0, providers_1.buildDetectedRuntime)({
+                    runtimeName: this.runtimeName,
+                    runtimeType: this.runtimeType,
+                    endpoint: this.endpoint,
+                    status: 'detected',
+                    lastSeenAt: now,
+                }),
+                models,
+                error: null,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                runtime: (0, providers_1.buildDetectedRuntime)({
+                    runtimeName: this.runtimeName,
+                    runtimeType: this.runtimeType,
+                    endpoint: this.endpoint,
+                    status: 'error',
+                    lastSeenAt: now,
+                    error: error instanceof Error ? error.message : 'request_failed',
+                }),
+                models: [],
+                error: error instanceof Error ? error.message : 'request_failed',
+            };
+        }
+    }
+}
+exports.OllamaProvider = OllamaProvider;
+//# sourceMappingURL=ollama.js.map

package/dist/v1/openai-compatible.d.ts

@@ -0,0 +1,12 @@
+import { type RuntimeProvider, type RuntimeProviderScanResult } from './providers';
+export declare function getDefaultOpenAICompatibleEndpoints(raw?: string): string[];
+export declare class OpenAICompatibleProvider implements RuntimeProvider {
+    readonly endpoint: string;
+    private readonly fetchImpl;
+    readonly runtimeName = "openai-compatible";
+    readonly runtimeType: "local-http";
+    constructor(endpoint?: string, fetchImpl?: typeof fetch);
+    scan(): Promise<RuntimeProviderScanResult>;
+}
+export declare function createDefaultOpenAICompatibleProviders(fetchImpl?: typeof fetch): OpenAICompatibleProvider[];
+//# sourceMappingURL=openai-compatible.d.ts.map

package/dist/v1/openai-compatible.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAICompatibleProvider = void 0;
+exports.getDefaultOpenAICompatibleEndpoints = getDefaultOpenAICompatibleEndpoints;
+exports.createDefaultOpenAICompatibleProviders = createDefaultOpenAICompatibleProviders;
+const discovery_1 = require("./discovery");
+const providers_1 = require("./providers");
+const DEFAULT_OPENAI_COMPATIBLE_ENDPOINT = 'http://localhost:8000';
+function normalizeConfiguredEndpoint(endpoint) {
+    const trimmed = String(endpoint || '').trim().replace(/\/+$/, '');
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const url = new URL(trimmed);
+        return `${url.protocol}//${url.host}${url.pathname === '/' ? '' : url.pathname}`.replace(/\/+$/, '');
+    }
+    catch {
+        return trimmed;
+    }
+}
+function getDefaultOpenAICompatibleEndpoints(raw = process.env.FORKIT_OPENAI_COMPATIBLE_ENDPOINTS ?? DEFAULT_OPENAI_COMPATIBLE_ENDPOINT) {
+    const candidates = String(raw || '')
+        .split(/[,\n]/)
+        .map((entry) => normalizeConfiguredEndpoint(entry))
+        .filter((entry) => Boolean(entry));
+    const seen = new Set();
+    const endpoints = [];
+    for (const candidate of candidates) {
+        if (seen.has(candidate))
+            continue;
+        seen.add(candidate);
+        endpoints.push(candidate);
+    }
+    return endpoints.length > 0 ? endpoints : [DEFAULT_OPENAI_COMPATIBLE_ENDPOINT];
+}
+class OpenAICompatibleProvider {
+    endpoint;
+    fetchImpl;
+    runtimeName = 'openai-compatible';
+    runtimeType = 'local-http';
+    constructor(endpoint = DEFAULT_OPENAI_COMPATIBLE_ENDPOINT, fetchImpl = fetch) {
+        this.endpoint = endpoint;
+        this.fetchImpl = fetchImpl;
+    }
+    async scan() {
+        const modelsEndpoint = `${this.endpoint}/v1/models`;
+        const now = new Date().toISOString();
+        const endpointHashFragment = (0, discovery_1.buildEndpointHash)(this.endpoint).slice(0, 12);
+        try {
+            const response = await this.fetchImpl(modelsEndpoint, { method: 'GET' });
+            if (!response.ok) {
+                return {
+                    ok: false,
+                    runtime: (0, providers_1.buildDetectedRuntime)({
+                        runtimeName: this.runtimeName,
+                        runtimeType: this.runtimeType,
+                        endpoint: this.endpoint,
+                        status: 'error',
+                        lastSeenAt: now,
+                        error: `http_${response.status}`,
+                    }),
+                    models: [],
+                    error: `http_${response.status}`,
+                };
+            }
+            const body = await response.json();
+            const models = (body.data ?? [])
+                .map((entry) => {
+                const modelId = String(entry.id ?? '').trim();
+                if (!modelId)
+                    return null;
+                return (0, providers_1.normalizeDetectedModel)({
+                    runtimeName: this.runtimeName,
+                    runtimeType: this.runtimeType,
+                    modelName: modelId,
+                    modelId,
+                    sourceEndpoint: this.endpoint,
+                    detectedAt: now,
+                    digest: `openai-compatible:${endpointHashFragment}:${modelId}`,
+                    metadata: {
+                        api_shape: 'openai-compatible',
+                        object: typeof entry.object === 'string' ? entry.object : null,
+                        owned_by: typeof entry.owned_by === 'string' ? entry.owned_by : null,
+                        created: entry.created ?? null,
+                    },
+                });
+            })
+                .filter((item) => Boolean(item));
+            return {
+                ok: true,
+                runtime: (0, providers_1.buildDetectedRuntime)({
+                    runtimeName: this.runtimeName,
+                    runtimeType: this.runtimeType,
+                    endpoint: this.endpoint,
+                    status: 'detected',
+                    lastSeenAt: now,
+                }),
+                models,
+                error: null,
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                runtime: (0, providers_1.buildDetectedRuntime)({
+                    runtimeName: this.runtimeName,
+                    runtimeType: this.runtimeType,
+                    endpoint: this.endpoint,
+                    status: 'error',
+                    lastSeenAt: now,
+                    error: error instanceof Error ? error.message : 'request_failed',
+                }),
+                models: [],
+                error: error instanceof Error ? error.message : 'request_failed',
+            };
+        }
+    }
+}
+exports.OpenAICompatibleProvider = OpenAICompatibleProvider;
+function createDefaultOpenAICompatibleProviders(fetchImpl = fetch) {
+    return getDefaultOpenAICompatibleEndpoints().map((endpoint) => new OpenAICompatibleProvider(endpoint, fetchImpl));
+}
+//# sourceMappingURL=openai-compatible.js.map

package/dist/v1/process-scout.d.ts

@@ -0,0 +1,50 @@
+import type { AgentType, RuntimePassportConfidence, SanitizedProcessMetadata } from './types';
+export interface ProcessListEntry {
+    pid: number;
+    ppid?: number;
+    name?: string;
+    cmd?: string;
+}
+type ProcessDetectionMode = 'signature' | 'heuristic';
+export interface ProcessScoutSignature {
+    signature: string;
+    knownProvider: string | null;
+    providerHints?: string[];
+    expectedPorts?: number[];
+    aliases?: string[];
+    confidence?: RuntimePassportConfidence;
+    sourceLabel?: string;
+    match(processName: string, command: string): boolean;
+}
+export interface AgentProcessMetadata {
+    process_name: string;
+    executable_name: string;
+    signature: string;
+    matched_terms: string[];
+    command_hash: string | null;
+    path_hash: string | null;
+    agent_name: string;
+    agent_type: AgentType;
+    confidence?: RuntimePassportConfidence;
+    detection_mode?: ProcessDetectionMode;
+    source_label?: string;
+    reason?: string | null;
+}
+export interface AgentProcessSignature {
+    signature: string;
+    agentType: AgentType;
+    agentName: string;
+    aliases?: string[];
+    confidence?: RuntimePassportConfidence;
+    sourceLabel?: string;
+    match(processName: string, command: string): boolean;
+}
+export declare const AI_PROCESS_SIGNATURES: ProcessScoutSignature[];
+export declare const AGENT_PROCESS_SIGNATURES: AgentProcessSignature[];
+export declare function classifyProcessEntry(entry: ProcessListEntry): SanitizedProcessMetadata | null;
+export declare function matchesRuntimeObservation(process: Pick<SanitizedProcessMetadata, 'known_provider' | 'signature' | 'provider_hints' | 'expected_ports'>, runtimeName: string, runtimeEndpoint: string): boolean;
+export declare function classifyAgentProcessEntry(entry: ProcessListEntry): AgentProcessMetadata | null;
+export declare function scanLikelyAiProcesses(listFn?: () => Promise<ProcessListEntry[]>): Promise<SanitizedProcessMetadata[]>;
+export declare function scanLikelyAgentProcesses(listFn?: () => Promise<ProcessListEntry[]>): Promise<AgentProcessMetadata[]>;
+export {};
+//# sourceMappingURL=process-scout.d.ts.map