forkit-connect 0.1.0

package/dist/v1/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/v1/update.d.ts

@@ -0,0 +1,38 @@
+export interface ReleaseDownloadEntry {
+    url?: string | null;
+    checksumSha256?: string | null;
+}
+export interface ReleaseManifest {
+    latestVersion: string;
+    minimumSupportedVersion: string;
+    releaseDate: string;
+    releaseNotesUrl: string;
+    downloads: {
+        macos?: ReleaseDownloadEntry | null;
+        windows?: ReleaseDownloadEntry | null;
+        windowsMsi?: ReleaseDownloadEntry | null;
+        linuxAppImage?: ReleaseDownloadEntry | null;
+        linuxDeb?: ReleaseDownloadEntry | null;
+    };
+    updateMessage?: string | null;
+}
+export interface ReleaseCheckSuccess {
+    ok: true;
+    manifestUrl: string;
+    currentVersion: string;
+    manifest: ReleaseManifest;
+    availability: 'up-to-date' | 'update-available' | 'required-update';
+    downloadUrl: string | null;
+}
+export interface ReleaseCheckFailure {
+    ok: false;
+    manifestUrl: string;
+    currentVersion: string;
+    error: string;
+}
+export type ReleaseCheckResult = ReleaseCheckSuccess | ReleaseCheckFailure;
+export declare function getCurrentConnectVersion(): string;
+export declare function getReleaseManifestUrl(): string;
+export declare function checkForUpdates(manifestUrl?: string): Promise<ReleaseCheckResult>;
+export declare function formatUpdateCheckLines(result: ReleaseCheckResult): string[];
+//# sourceMappingURL=update.d.ts.map

package/dist/v1/update.js

@@ -0,0 +1,184 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentConnectVersion = getCurrentConnectVersion;
+exports.getReleaseManifestUrl = getReleaseManifestUrl;
+exports.checkForUpdates = checkForUpdates;
+exports.formatUpdateCheckLines = formatUpdateCheckLines;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_url_1 = require("node:url");
+const DEFAULT_RELEASE_MANIFEST_URL = process.env.FORKIT_CONNECT_RELEASE_MANIFEST_URL ?? 'https://forkit.dev/connect/releases/latest.json';
+function readPackageJsonVersion() {
+    try {
+        const packageJsonPath = node_path_1.default.resolve(__dirname, '..', '..', 'package.json');
+        const raw = node_fs_1.default.readFileSync(packageJsonPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === 'string' && parsed.version.trim() ? parsed.version.trim() : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function parseVersion(version) {
+    const cleaned = String(version || '').trim().replace(/^v/i, '').split('-')[0] || '0.0.0';
+    const [major, minor, patch] = cleaned.split('.').map((value) => Number.parseInt(value || '0', 10));
+    return [major || 0, minor || 0, patch || 0];
+}
+function compareVersions(left, right) {
+    const [leftMajor, leftMinor, leftPatch] = parseVersion(left);
+    const [rightMajor, rightMinor, rightPatch] = parseVersion(right);
+    if (leftMajor > rightMajor)
+        return 1;
+    if (leftMajor < rightMajor)
+        return -1;
+    if (leftMinor > rightMinor)
+        return 1;
+    if (leftMinor < rightMinor)
+        return -1;
+    if (leftPatch > rightPatch)
+        return 1;
+    if (leftPatch < rightPatch)
+        return -1;
+    return 0;
+}
+function isReleaseManifest(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    return (typeof record.latestVersion === 'string'
+        && typeof record.minimumSupportedVersion === 'string'
+        && typeof record.releaseDate === 'string'
+        && typeof record.releaseNotesUrl === 'string'
+        && !!record.downloads
+        && typeof record.downloads === 'object');
+}
+function pickDownloadUrl(downloads) {
+    if (process.platform === 'darwin') {
+        return downloads.macos?.url || null;
+    }
+    if (process.platform === 'win32') {
+        return downloads.windows?.url || null;
+    }
+    return downloads.linuxAppImage?.url || downloads.linuxDeb?.url || null;
+}
+function getCurrentConnectVersion() {
+    return readPackageJsonVersion();
+}
+function getReleaseManifestUrl() {
+    return DEFAULT_RELEASE_MANIFEST_URL;
+}
+async function checkForUpdates(manifestUrl = getReleaseManifestUrl()) {
+    const currentVersion = getCurrentConnectVersion();
+    try {
+        if (manifestUrl.startsWith('file://')) {
+            const manifestPath = (0, node_url_1.fileURLToPath)(manifestUrl);
+            const raw = await node_fs_1.default.promises.readFile(manifestPath, 'utf8');
+            const body = JSON.parse(raw);
+            if (!isReleaseManifest(body)) {
+                return {
+                    ok: false,
+                    manifestUrl,
+                    currentVersion,
+                    error: 'invalid_manifest',
+                };
+            }
+            const minimumSupportedComparison = compareVersions(currentVersion, body.minimumSupportedVersion);
+            const latestComparison = compareVersions(currentVersion, body.latestVersion);
+            const availability = minimumSupportedComparison < 0
+                ? 'required-update'
+                : latestComparison < 0
+                    ? 'update-available'
+                    : 'up-to-date';
+            return {
+                ok: true,
+                manifestUrl,
+                currentVersion,
+                manifest: body,
+                availability,
+                downloadUrl: pickDownloadUrl(body.downloads),
+            };
+        }
+        const response = await fetch(manifestUrl, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+            },
+        });
+        if (!response.ok) {
+            return {
+                ok: false,
+                manifestUrl,
+                currentVersion,
+                error: `manifest_http_${response.status}`,
+            };
+        }
+        const body = await response.json();
+        if (!isReleaseManifest(body)) {
+            return {
+                ok: false,
+                manifestUrl,
+                currentVersion,
+                error: 'invalid_manifest',
+            };
+        }
+        const minimumSupportedComparison = compareVersions(currentVersion, body.minimumSupportedVersion);
+        const latestComparison = compareVersions(currentVersion, body.latestVersion);
+        const availability = minimumSupportedComparison < 0
+            ? 'required-update'
+            : latestComparison < 0
+                ? 'update-available'
+                : 'up-to-date';
+        return {
+            ok: true,
+            manifestUrl,
+            currentVersion,
+            manifest: body,
+            availability,
+            downloadUrl: pickDownloadUrl(body.downloads),
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            manifestUrl,
+            currentVersion,
+            error: error instanceof Error ? error.message : 'manifest_fetch_failed',
+        };
+    }
+}
+function formatUpdateCheckLines(result) {
+    if (!result.ok) {
+        return [
+            'Update check failed.',
+            `Manifest: ${result.manifestUrl}`,
+            `Reason: ${result.error}`,
+        ];
+    }
+    const lines = [];
+    if (result.availability === 'required-update') {
+        lines.push('Required update available.');
+        lines.push('This version is no longer supported.');
+    }
+    else if (result.availability === 'update-available') {
+        lines.push('Update available.');
+    }
+    else {
+        lines.push('Forkit Connect is up to date.');
+    }
+    lines.push(`Current version: ${result.currentVersion}`);
+    lines.push(`Latest version: ${result.manifest.latestVersion}`);
+    if (result.availability !== 'up-to-date') {
+        if (result.downloadUrl) {
+            lines.push(`Download: ${result.downloadUrl}`);
+        }
+        lines.push(`Release notes: ${result.manifest.releaseNotesUrl}`);
+        if (result.manifest.updateMessage) {
+            lines.push(`Message: ${result.manifest.updateMessage}`);
+        }
+    }
+    return lines;
+}
+//# sourceMappingURL=update.js.map

package/dist/v1/vitality-pulse.d.ts

@@ -0,0 +1,36 @@
+import { type ProcessListEntry } from './process-scout';
+import type { ConnectState, ProviderHealthStatus, PulseStatus, SanitizedProcessMetadata, VitalityPulseEvent, VitalityPulseSummary } from './types';
+export interface RawProcessMetricsEntry extends ProcessListEntry {
+    cpu?: number;
+    memory?: number;
+}
+export interface GpuSample {
+    gpu_available: boolean;
+    gpu_vram_used_mb: number | null;
+    gpu_utilization_percent: number | null;
+}
+export interface VitalityPulseDependencies {
+    processScoutResults?: SanitizedProcessMetadata[];
+    processList?: () => Promise<RawProcessMetricsEntry[]>;
+    portChecker?: (endpoint: string) => Promise<boolean>;
+    gpuProbe?: () => Promise<GpuSample>;
+    processUptimeProbe?: (pid: number) => Promise<number | null>;
+    measuredAt?: string;
+}
+export declare function checkEndpointPortAlive(endpoint: string, timeoutMs?: number): Promise<boolean>;
+export declare function probeGpuHealth(): Promise<GpuSample>;
+export declare function classifyPulseStatus(input: {
+    inventoryOnly?: boolean;
+    knownRuntime: boolean;
+    providerStatus: ProviderHealthStatus;
+    portAlive: boolean | null;
+    processAlive: boolean | null;
+    cpuUsagePercent: number | null;
+    memoryUsageMb: number | null;
+    gpuAvailable: boolean;
+    gpuUtilizationPercent: number | null;
+    gpuVramUsedMb: number | null;
+}): PulseStatus;
+export declare function collectVitalityPulse(state: ConnectState, dependencies?: VitalityPulseDependencies): Promise<VitalityPulseSummary>;
+export declare function buildPulseEvents(summary: VitalityPulseSummary): Array<Omit<VitalityPulseEvent, 'event_id'>>;
+//# sourceMappingURL=vitality-pulse.d.ts.map