forkit-connect 0.1.0

package/dist/v1/discovery.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEndpointPort = readEndpointPort;
+exports.buildEndpointHash = buildEndpointHash;
+exports.buildSourceEndpointLabel = buildSourceEndpointLabel;
+exports.buildRuntimePassportGaid = buildRuntimePassportGaid;
+exports.buildRuntimeDiscoveryHash = buildRuntimeDiscoveryHash;
+exports.buildModelDiscoveryHash = buildModelDiscoveryHash;
+exports.buildModelRegistrationKey = buildModelRegistrationKey;
+exports.buildAgentDiscoveryHash = buildAgentDiscoveryHash;
+exports.buildRuntimeAttestationFingerprint = buildRuntimeAttestationFingerprint;
+exports.buildModelObservationFingerprint = buildModelObservationFingerprint;
+exports.applyRuntimeDiscovery = applyRuntimeDiscovery;
+exports.applyModelDiscovery = applyModelDiscovery;
+const node_crypto_1 = require("node:crypto");
+function stableObjectStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableObjectStringify(item)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+        return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${stableObjectStringify(entryValue)}`).join(',')}}`;
+    }
+    return JSON.stringify(value ?? null);
+}
+function normalizeEndpointForIdentity(sourceEndpoint) {
+    try {
+        const url = new URL(sourceEndpoint);
+        const port = url.port || (url.protocol === 'https:' ? '443' : '80');
+        const pathname = url.pathname && url.pathname !== '/' ? url.pathname : '';
+        return `${url.protocol}//${url.hostname}:${port}${pathname}`;
+    }
+    catch {
+        return String(sourceEndpoint || '').trim();
+    }
+}
+function readEndpointPort(sourceEndpoint) {
+    try {
+        const url = new URL(sourceEndpoint);
+        const port = url.port || (url.protocol === 'https:' ? '443' : '80');
+        const parsed = Number.parseInt(port, 10);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function buildEndpointHash(sourceEndpoint) {
+    const normalized = normalizeEndpointForIdentity(sourceEndpoint);
+    return (0, node_crypto_1.createHash)('sha256').update(normalized, 'utf8').digest('hex');
+}
+function buildSourceEndpointLabel(sourceEndpoint) {
+    if (sourceEndpoint.startsWith('local://filesystem')) {
+        return 'local-model-files';
+    }
+    try {
+        const url = new URL(sourceEndpoint);
+        const port = url.port || (url.protocol === 'https:' ? '443' : '80');
+        return `${url.hostname}:${port}`;
+    }
+    catch {
+        return 'local-runtime-endpoint';
+    }
+}
+function buildRuntimePassportGaid(input) {
+    const stablePayload = stableObjectStringify({
+        connect_device_id: input.connectDeviceId,
+        runtime_name: input.runtimeName,
+        runtime_type: input.runtimeType,
+        provider: input.provider,
+        endpoint_hash: input.endpointHash,
+    });
+    return `runtime:${(0, node_crypto_1.createHash)('sha256').update(stablePayload, 'utf8').digest('hex').slice(0, 32)}`;
+}
+function buildRuntimeDiscoveryHash(input) {
+    const stablePayload = stableObjectStringify({
+        runtime_name: input.runtimeName,
+        runtime_type: input.runtimeType,
+        source_endpoint: input.sourceEndpoint,
+        runtime_identity: input.runtimeIdentity,
+    });
+    return (0, node_crypto_1.createHash)('sha256').update(stablePayload, 'utf8').digest('hex');
+}
+function buildModelDiscoveryHash(input) {
+    const stablePayload = stableObjectStringify({
+        runtime_name: input.runtimeName,
+        runtime_type: input.runtimeType,
+        model_name: input.modelName,
+        model_id: input.modelId,
+        source_endpoint: input.sourceEndpoint,
+        runtime_identity: input.runtimeIdentity,
+    });
+    return (0, node_crypto_1.createHash)('sha256').update(stablePayload, 'utf8').digest('hex');
+}
+function buildModelRegistrationKey(model, runtimeIdentity) {
+    const stablePayload = stableObjectStringify({
+        model_name: model.model,
+        model_id: model.modelId ?? null,
+        runtime_identity: runtimeIdentity,
+    });
+    return (0, node_crypto_1.createHash)('sha256').update(stablePayload, 'utf8').digest('hex');
+}
+function buildAgentDiscoveryHash(input) {
+    const stablePayload = stableObjectStringify({
+        agent_name: input.agentName,
+        agent_type: input.agentType,
+        process_signature_hash: input.processSignatureHash,
+        runtime_identity: input.runtimeIdentity,
+    });
+    return (0, node_crypto_1.createHash)('sha256').update(stablePayload, 'utf8').digest('hex');
+}
+function buildRuntimeAttestationFingerprint(input) {
+    const stablePayload = stableObjectStringify({
+        runtime_name: input.runtimeName,
+        runtime_type: input.runtimeType,
+        runtime_provider: input.runtimeProvider,
+        endpoint_hash: input.endpointHash,
+        runtime_identity: input.runtimeIdentity,
+        process_signature: input.processSignature,
+        process_command_hash: input.processCommandHash,
+        process_path_hash: input.processPathHash,
+        detection_mode: input.detectionMode,
+        source_label: input.sourceLabel,
+        matched_terms: [...new Set(input.matchedTerms.filter(Boolean))].sort((left, right) => left.localeCompare(right)),
+        expected_ports: [...new Set(input.expectedPorts.filter((port) => Number.isFinite(port) && port > 0))].sort((left, right) => left - right),
+    });
+    return (0, node_crypto_1.createHash)('sha256').update(stablePayload, 'utf8').digest('hex');
+}
+function buildModelObservationFingerprint(input) {
+    const stablePayload = stableObjectStringify({
+        runtime_name: input.runtimeName,
+        runtime_type: input.runtimeType,
+        model_name: input.modelName,
+        model_id: input.modelId,
+        digest: input.digest,
+        size_bytes: input.sizeBytes,
+        modified_at: input.modifiedAt,
+        metadata_fingerprint: input.metadataFingerprint,
+    });
+    return (0, node_crypto_1.createHash)('sha256').update(stablePayload, 'utf8').digest('hex');
+}
+function applyRuntimeDiscovery(runtime, runtimeIdentity, sources = ['provider_scan']) {
+    return {
+        ...runtime,
+        discoveryHash: buildRuntimeDiscoveryHash({
+            runtimeName: runtime.runtimeName,
+            runtimeType: runtime.runtimeType,
+            sourceEndpoint: runtime.endpoint,
+            runtimeIdentity,
+        }),
+        discoverySources: [...new Set(sources)],
+    };
+}
+function applyModelDiscovery(model, runtimeIdentity, sources = ['provider_scan']) {
+    return {
+        ...model,
+        discoveryHash: buildModelDiscoveryHash({
+            runtimeName: model.runtimeName,
+            runtimeType: model.runtimeType,
+            modelName: model.model,
+            modelId: model.modelId,
+            sourceEndpoint: model.sourceEndpoint,
+            runtimeIdentity,
+        }),
+        discoverySources: [...new Set(sources)],
+    };
+}
+//# sourceMappingURL=discovery.js.map

package/dist/v1/filesystem-models.d.ts

@@ -0,0 +1,11 @@
+import { type RuntimeProvider, type RuntimeProviderScanResult } from './providers';
+export declare class FilesystemModelProvider implements RuntimeProvider {
+    private readonly roots;
+    readonly runtimeName = "local-model-files";
+    readonly runtimeType: "local-filesystem";
+    readonly endpoint = "local://filesystem";
+    constructor(roots: string[]);
+    scan(): Promise<RuntimeProviderScanResult>;
+}
+export declare function createDefaultFilesystemModelProviders(): FilesystemModelProvider[];
+//# sourceMappingURL=filesystem-models.d.ts.map

package/dist/v1/filesystem-models.js

@@ -0,0 +1,261 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesystemModelProvider = void 0;
+exports.createDefaultFilesystemModelProviders = createDefaultFilesystemModelProviders;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const providers_1 = require("./providers");
+const DEFAULT_MAX_SCAN_DEPTH = 6;
+const DEFAULT_MAX_MODELS = 250;
+const DEFAULT_MIN_MODEL_BYTES = 8 * 1024 * 1024;
+const MODEL_FILE_EXTENSIONS = new Set([
+    '.gguf',
+    '.ggml',
+    '.safetensors',
+    '.onnx',
+    '.pt',
+    '.pth',
+    '.bin',
+]);
+function expandHomeDir(input) {
+    if (!input.startsWith('~/'))
+        return input;
+    return node_path_1.default.join(node_os_1.default.homedir(), input.slice(2));
+}
+function normalizeConfiguredDir(value) {
+    const trimmed = expandHomeDir(String(value || '').trim());
+    return trimmed ? node_path_1.default.resolve(trimmed) : null;
+}
+function getDefaultFilesystemModelDirs() {
+    const home = node_os_1.default.homedir();
+    const candidates = [
+        process.env.FORKIT_LOCAL_MODEL_SCAN_DIRS,
+        node_path_1.default.join(home, '.cache', 'huggingface', 'hub'),
+        process.env.HF_HOME ? node_path_1.default.join(process.env.HF_HOME, 'hub') : null,
+        node_path_1.default.join(home, '.cache', 'lm-studio', 'models'),
+        node_path_1.default.join(home, '.lmstudio', 'models'),
+        node_path_1.default.join(home, 'models'),
+        node_path_1.default.join(home, 'model'),
+        node_path_1.default.join(home, 'ai', 'models'),
+        node_path_1.default.join(home, '.cache', 'mlx-models'),
+    ].filter((value) => Boolean(value));
+    const seen = new Set();
+    const directories = [];
+    for (const candidateGroup of candidates) {
+        const values = String(candidateGroup)
+            .split(/[\n,]/)
+            .map((entry) => normalizeConfiguredDir(entry))
+            .filter((entry) => Boolean(entry));
+        for (const value of values) {
+            if (seen.has(value))
+                continue;
+            seen.add(value);
+            directories.push(value);
+        }
+    }
+    return directories;
+}
+async function pathExists(targetPath) {
+    try {
+        await promises_1.default.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isGenericModelBasename(name) {
+    return ['model', 'pytorch_model', 'consolidated', 'weights', 'adapter_model'].includes(name.toLowerCase());
+}
+function stripModelExtension(filename) {
+    const extension = node_path_1.default.extname(filename);
+    return extension ? filename.slice(0, -extension.length) : filename;
+}
+function makeRelativeHint(filePath, rootDir) {
+    const relative = node_path_1.default.relative(rootDir, filePath);
+    const parts = relative.split(node_path_1.default.sep).filter(Boolean);
+    return parts.slice(-4).join('/');
+}
+function deriveHuggingFaceModelName(filePath) {
+    const normalized = filePath.split(node_path_1.default.sep);
+    const repoMarker = normalized.find((part) => part.startsWith('models--'));
+    if (!repoMarker)
+        return null;
+    const repoName = repoMarker.replace(/^models--/, '').replaceAll('--', '/');
+    return repoName || null;
+}
+function deriveModelName(filePath, rootDir) {
+    const huggingFaceName = deriveHuggingFaceModelName(filePath);
+    if (huggingFaceName) {
+        return { modelName: huggingFaceName, sourceKind: 'huggingface-cache' };
+    }
+    const parsed = node_path_1.default.parse(filePath);
+    const baseName = stripModelExtension(parsed.base);
+    if (!isGenericModelBasename(baseName)) {
+        return { modelName: baseName, sourceKind: 'local-model-dir' };
+    }
+    const relativeDir = node_path_1.default.relative(rootDir, parsed.dir).split(node_path_1.default.sep).filter(Boolean);
+    const parentName = relativeDir.at(-1) || baseName;
+    return { modelName: parentName, sourceKind: 'local-model-dir' };
+}
+function buildSyntheticDigest(input) {
+    return (0, node_crypto_1.createHash)('sha256').update(input, 'utf8').digest('hex');
+}
+async function collectModelFiles(rootDir, currentDir, depth, found) {
+    if (depth > DEFAULT_MAX_SCAN_DEPTH || found.length >= DEFAULT_MAX_MODELS) {
+        return;
+    }
+    let entries;
+    try {
+        entries = await promises_1.default.readdir(currentDir, { withFileTypes: true, encoding: 'utf8' });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (found.length >= DEFAULT_MAX_MODELS) {
+            return;
+        }
+        const fullPath = node_path_1.default.join(currentDir, entry.name);
+        if (fullPath.includes(`${node_path_1.default.sep}.no_exist${node_path_1.default.sep}`)) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            await collectModelFiles(rootDir, fullPath, depth + 1, found);
+            continue;
+        }
+        if (!entry.isFile() && !entry.isSymbolicLink()) {
+            continue;
+        }
+        const extension = node_path_1.default.extname(entry.name).toLowerCase();
+        if (!MODEL_FILE_EXTENSIONS.has(extension)) {
+            continue;
+        }
+        let stats;
+        try {
+            stats = await promises_1.default.stat(fullPath);
+        }
+        catch {
+            continue;
+        }
+        if (!stats.isFile()) {
+            continue;
+        }
+        if (stats.size < DEFAULT_MIN_MODEL_BYTES) {
+            continue;
+        }
+        const { modelName, sourceKind } = deriveModelName(fullPath, rootDir);
+        const relativeHint = makeRelativeHint(fullPath, rootDir);
+        found.push({
+            modelName,
+            modelId: `${modelName}#${relativeHint}`,
+            totalSizeBytes: stats.size,
+            modifiedAt: Number.isFinite(stats.mtimeMs) ? new Date(stats.mtimeMs).toISOString() : null,
+            fileExtension: extension,
+            rootDir,
+            relativeHint,
+            sourceKind,
+        });
+    }
+}
+function collapseFilesystemCandidates(candidates) {
+    const grouped = new Map();
+    for (const candidate of candidates) {
+        const key = `${candidate.sourceKind}#${candidate.modelName}`;
+        const existing = grouped.get(key);
+        if (!existing) {
+            grouped.set(key, candidate);
+            continue;
+        }
+        grouped.set(key, {
+            ...existing,
+            totalSizeBytes: existing.totalSizeBytes + candidate.totalSizeBytes,
+            modifiedAt: [existing.modifiedAt, candidate.modifiedAt].filter(Boolean).sort().at(-1) ?? existing.modifiedAt,
+            relativeHint: existing.relativeHint.length >= candidate.relativeHint.length ? existing.relativeHint : candidate.relativeHint,
+        });
+    }
+    return [...grouped.values()].sort((left, right) => right.totalSizeBytes - left.totalSizeBytes || left.modelName.localeCompare(right.modelName));
+}
+class FilesystemModelProvider {
+    roots;
+    runtimeName = 'local-model-files';
+    runtimeType = 'local-filesystem';
+    endpoint = 'local://filesystem';
+    constructor(roots) {
+        this.roots = roots;
+    }
+    async scan() {
+        const now = new Date().toISOString();
+        const existingRoots = [];
+        for (const root of this.roots) {
+            if (await pathExists(root)) {
+                existingRoots.push(root);
+            }
+        }
+        if (existingRoots.length === 0) {
+            return {
+                ok: false,
+                runtime: (0, providers_1.buildDetectedRuntime)({
+                    runtimeName: this.runtimeName,
+                    runtimeType: this.runtimeType,
+                    endpoint: this.endpoint,
+                    status: 'error',
+                    lastSeenAt: now,
+                    error: 'no_model_directories_found',
+                }),
+                models: [],
+                error: 'no_model_directories_found',
+            };
+        }
+        const rawCandidates = [];
+        for (const root of existingRoots) {
+            await collectModelFiles(root, root, 0, rawCandidates);
+        }
+        const models = collapseFilesystemCandidates(rawCandidates)
+            .slice(0, DEFAULT_MAX_MODELS)
+            .map((candidate) => (0, providers_1.normalizeDetectedModel)({
+            runtimeName: this.runtimeName,
+            runtimeType: this.runtimeType,
+            modelName: candidate.modelName,
+            modelId: candidate.modelId,
+            sourceEndpoint: this.endpoint,
+            detectedAt: now,
+            digest: buildSyntheticDigest(`${candidate.modelName}|${candidate.relativeHint}|${candidate.totalSizeBytes}|${candidate.modifiedAt || ''}`),
+            sizeBytes: candidate.totalSizeBytes,
+            modifiedAt: candidate.modifiedAt,
+            sourceLabel: 'Verified by Integration',
+            metadata: {
+                inventory_source: 'filesystem_scan',
+                source_kind: candidate.sourceKind,
+                root_label: node_path_1.default.basename(candidate.rootDir) || 'model-root',
+                relative_path_hint: candidate.relativeHint,
+                file_extension: candidate.fileExtension,
+            },
+        }));
+        return {
+            ok: models.length > 0,
+            runtime: (0, providers_1.buildDetectedRuntime)({
+                runtimeName: this.runtimeName,
+                runtimeType: this.runtimeType,
+                endpoint: this.endpoint,
+                status: models.length > 0 ? 'detected' : 'error',
+                lastSeenAt: now,
+                error: models.length > 0 ? null : 'no_model_files_found',
+                sourceLabel: 'Verified by Integration',
+            }),
+            models,
+            error: models.length > 0 ? null : 'no_model_files_found',
+        };
+    }
+}
+exports.FilesystemModelProvider = FilesystemModelProvider;
+function createDefaultFilesystemModelProviders() {
+    const roots = getDefaultFilesystemModelDirs();
+    return roots.length > 0 ? [new FilesystemModelProvider(roots)] : [];
+}
+//# sourceMappingURL=filesystem-models.js.map

package/dist/v1/heartbeat.d.ts

@@ -0,0 +1,45 @@
+import { ConnectV1Service } from './service';
+import type { ConnectState, DetectedModel, ModelBinding } from './types';
+export interface BoundBindingSelection {
+    binding: ModelBinding;
+    detectedModel: DetectedModel | undefined;
+}
+export interface HeartbeatSuccess {
+    ok: true;
+    gaid: string;
+    modelName: string;
+    sessionId: string;
+    lastCheckinAt: string | null;
+}
+export interface HeartbeatFailure {
+    ok: false;
+    code: 'not_authenticated' | 'missing_binding' | 'missing_model' | 'passport_inaccessible' | 'governor_paused' | 'access_revoked' | 'credential_reconnect_needed' | 'binding_paused' | 'binding_stale' | 'binding_reconsent_required' | 'heartbeat_failed';
+    message: string;
+    status?: number;
+    details?: unknown;
+}
+export type HeartbeatResult = HeartbeatSuccess | HeartbeatFailure;
+export interface HeartbeatBatchEntry {
+    gaid: string;
+    modelName: string;
+    runtimeSignalQueueId: string | null;
+    result: HeartbeatResult;
+}
+export interface HeartbeatBatchResult {
+    attempted: number;
+    succeeded: number;
+    failed: number;
+    runtimeSignalQueued: number;
+    results: HeartbeatBatchEntry[];
+}
+export declare function readBoundModelName(modelKey: string): string;
+export declare function listBoundBindings(state: ConnectState): BoundBindingSelection[];
+export declare function selectBoundBinding(state: ConnectState): BoundBindingSelection | null;
+export declare function sendAllBoundHeartbeats(service: ConnectV1Service, options?: {
+    baseUrl?: string;
+    queueRuntimeSignal?: boolean;
+}): Promise<HeartbeatBatchResult>;
+export declare function sendBoundHeartbeat(service: ConnectV1Service, options?: {
+    baseUrl?: string;
+}): Promise<HeartbeatResult>;
+//# sourceMappingURL=heartbeat.d.ts.map