forkit-connect 0.1.0

package/dist/v1/currency.d.ts

@@ -0,0 +1,41 @@
+/**
+ * currency.ts — locale-aware ISO 4217 currency resolution for the Connect daemon.
+ *
+ * Priority chain (highest to lowest confidence):
+ *   1. User session / profile (backend tells us the account's country).
+ *   2. System locale from Node.js Intl (ICU data, no network needed).
+ *   3. Hard fallback: 'USD' — only used when ICU data is unavailable.
+ *
+ * No hardcoded amounts or rates live here.  Cost amounts are always
+ * expressed in the resolved currency so the UI can format them with
+ * Intl.NumberFormat without any conversion.
+ */
+/**
+ * Derives the ISO 4217 currency code from a BCP-47 locale string.
+ * Returns null when the locale has no recognisable country subtag.
+ */
+export declare function currencyFromLocale(locale: string): string | null;
+/**
+ * Returns the system's default locale using Node.js ICU data.
+ * Falls back to 'en-US' if ICU is unavailable (--no-icu Node builds).
+ */
+export declare function getSystemLocale(): string;
+/**
+ * Resolves the ISO 4217 currency code for the current Connect session.
+ *
+ * @param sessionCountry  - ISO 3166-1 α-2 country from the user's backend profile (preferred).
+ *                          Pass `null` when the session hasn't loaded yet.
+ * @returns ISO 4217 currency code, e.g. 'USD', 'INR', 'EUR'.
+ *          Falls back to 'USD' as last resort (logged at debug level).
+ */
+export declare function resolveSessionCurrency(sessionCountry: string | null | undefined): string;
+/**
+ * Formats a cost amount for display inside the daemon's log output.
+ * The web UI uses Intl.NumberFormat directly for richer formatting.
+ *
+ * @param amount      - Numeric cost value.
+ * @param currency    - ISO 4217 currency code.
+ * @param confidence  - 'exact' | 'estimated' | 'relative'
+ */
+export declare function formatCostForLog(amount: number | null, currency: string | null, confidence: 'exact' | 'estimated' | 'relative'): string;
+//# sourceMappingURL=currency.d.ts.map

package/dist/v1/currency.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * currency.ts — locale-aware ISO 4217 currency resolution for the Connect daemon.
+ *
+ * Priority chain (highest to lowest confidence):
+ *   1. User session / profile (backend tells us the account's country).
+ *   2. System locale from Node.js Intl (ICU data, no network needed).
+ *   3. Hard fallback: 'USD' — only used when ICU data is unavailable.
+ *
+ * No hardcoded amounts or rates live here.  Cost amounts are always
+ * expressed in the resolved currency so the UI can format them with
+ * Intl.NumberFormat without any conversion.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currencyFromLocale = currencyFromLocale;
+exports.getSystemLocale = getSystemLocale;
+exports.resolveSessionCurrency = resolveSessionCurrency;
+exports.formatCostForLog = formatCostForLog;
+/** Compact, authoritative country→currency map (ISO 3166-1 α-2 → ISO 4217). */
+const COUNTRY_CURRENCY = {
+    // Americas
+    US: 'USD', CA: 'CAD', MX: 'MXN', BR: 'BRL', AR: 'ARS', CL: 'CLP',
+    CO: 'COP', PE: 'PEN', VE: 'VES', UY: 'UYU', PY: 'PYG', BO: 'BOB',
+    // Europe
+    DE: 'EUR', FR: 'EUR', IT: 'EUR', ES: 'EUR', PT: 'EUR', NL: 'EUR',
+    BE: 'EUR', AT: 'EUR', IE: 'EUR', FI: 'EUR', GR: 'EUR', LU: 'EUR',
+    SK: 'EUR', SI: 'EUR', CY: 'EUR', MT: 'EUR', EE: 'EUR', LV: 'EUR',
+    LT: 'EUR', HR: 'EUR',
+    GB: 'GBP', CH: 'CHF', SE: 'SEK', NO: 'NOK', DK: 'DKK', PL: 'PLN',
+    CZ: 'CZK', HU: 'HUF', RO: 'RON', BG: 'BGN', RS: 'RSD', UA: 'UAH',
+    TR: 'TRY', RU: 'RUB',
+    // Asia-Pacific
+    IN: 'INR', CN: 'CNY', JP: 'JPY', KR: 'KRW', AU: 'AUD', NZ: 'NZD',
+    SG: 'SGD', HK: 'HKD', TW: 'TWD', TH: 'THB', ID: 'IDR', MY: 'MYR',
+    PH: 'PHP', VN: 'VND', PK: 'PKR', BD: 'BDT', LK: 'LKR', NP: 'NPR',
+    MM: 'MMK', KH: 'KHR', MN: 'MNT', KZ: 'KZT', UZ: 'UZS',
+    // Middle-East & Africa
+    AE: 'AED', SA: 'SAR', QA: 'QAR', KW: 'KWD', BH: 'BHD', OM: 'OMR',
+    IQ: 'IQD', IR: 'IRR', IL: 'ILS', EG: 'EGP', ZA: 'ZAR', NG: 'NGN',
+    GH: 'GHS', KE: 'KES', TZ: 'TZS', ET: 'ETB', MA: 'MAD', DZ: 'DZD',
+    TN: 'TND',
+};
+/**
+ * Extracts the country code from a BCP-47 locale string.
+ * e.g. 'en-IN' → 'IN', 'zh-Hans-CN' → 'CN', 'fr' → null
+ */
+function countryFromLocale(locale) {
+    const parts = locale.split('-');
+    for (let i = parts.length - 1; i >= 1; i--) {
+        const part = parts[i];
+        if (part === undefined)
+            continue;
+        if (/^[A-Z]{2}$/.test(part))
+            return part;
+        if (/^[a-z]{2}$/.test(part))
+            return part.toUpperCase();
+    }
+    return null;
+}
+/**
+ * Derives the ISO 4217 currency code from a BCP-47 locale string.
+ * Returns null when the locale has no recognisable country subtag.
+ */
+function currencyFromLocale(locale) {
+    const country = countryFromLocale(locale);
+    if (!country)
+        return null;
+    return COUNTRY_CURRENCY[country] ?? null;
+}
+/**
+ * Returns the system's default locale using Node.js ICU data.
+ * Falls back to 'en-US' if ICU is unavailable (--no-icu Node builds).
+ */
+function getSystemLocale() {
+    try {
+        return new Intl.DateTimeFormat().resolvedOptions().locale || 'en-US';
+    }
+    catch {
+        return 'en-US';
+    }
+}
+/**
+ * Resolves the ISO 4217 currency code for the current Connect session.
+ *
+ * @param sessionCountry  - ISO 3166-1 α-2 country from the user's backend profile (preferred).
+ *                          Pass `null` when the session hasn't loaded yet.
+ * @returns ISO 4217 currency code, e.g. 'USD', 'INR', 'EUR'.
+ *          Falls back to 'USD' as last resort (logged at debug level).
+ */
+function resolveSessionCurrency(sessionCountry) {
+    // 1. Backend session country (most reliable — user explicitly set during registration)
+    if (sessionCountry) {
+        const code = COUNTRY_CURRENCY[sessionCountry.toUpperCase()];
+        if (code)
+            return code;
+    }
+    // 2. System locale (works offline, no network needed)
+    const systemLocale = getSystemLocale();
+    const localeCurrency = currencyFromLocale(systemLocale);
+    if (localeCurrency)
+        return localeCurrency;
+    // 3. Last resort — avoids null propagation; UI will show '~' prefix to signal estimation
+    return 'USD';
+}
+/**
+ * Formats a cost amount for display inside the daemon's log output.
+ * The web UI uses Intl.NumberFormat directly for richer formatting.
+ *
+ * @param amount      - Numeric cost value.
+ * @param currency    - ISO 4217 currency code.
+ * @param confidence  - 'exact' | 'estimated' | 'relative'
+ */
+function formatCostForLog(amount, currency, confidence) {
+    if (amount === null || currency === null)
+        return '(cost unavailable)';
+    if (confidence === 'relative') {
+        return `~${(amount * 100).toFixed(1)}% of team total`;
+    }
+    const prefix = confidence === 'estimated' ? '~' : '';
+    try {
+        return prefix + new Intl.NumberFormat('en', { style: 'currency', currency, maximumFractionDigits: 6 }).format(amount);
+    }
+    catch {
+        return `${prefix}${amount.toFixed(6)} ${currency}`;
+    }
+}
+//# sourceMappingURL=currency.js.map

package/dist/v1/daemon.d.ts

@@ -0,0 +1,50 @@
+import { ConnectV1Service, type DiscoveryCycleResult, type NotificationSender } from './service';
+import type { SanitizedProcessMetadata } from './types';
+import type { VitalityPulseDependencies } from './vitality-pulse';
+import type { ProcessListEntry } from './process-scout';
+export interface DaemonLaunchResult {
+    pid: number;
+    confirmed: boolean;
+    message: string | null;
+}
+export interface DaemonStopResult {
+    pid: number | null;
+    stopped: boolean;
+    message: string;
+}
+export interface DaemonHealthResult {
+    running: boolean;
+    pid: number | null;
+    alive: boolean;
+    lastScanAt: string | null;
+    lastError: string | null;
+}
+export declare function runDaemonScanCycle(service: ConnectV1Service, options?: {
+    processScoutResults?: SanitizedProcessMetadata[];
+    pulseDependencies?: VitalityPulseDependencies;
+    agentProcessEntries?: ProcessListEntry[];
+    notificationSender?: NotificationSender;
+}): Promise<DiscoveryCycleResult>;
+export declare function runDaemonLoopForeground(service: ConnectV1Service, options?: {
+    intervalSeconds?: number;
+    processScoutResults?: SanitizedProcessMetadata[];
+    pulseDependencies?: VitalityPulseDependencies;
+    agentProcessEntries?: ProcessListEntry[];
+    notificationSender?: NotificationSender;
+}): Promise<void>;
+export declare function getDaemonHealth(service: ConnectV1Service): DaemonHealthResult;
+export declare function waitForDaemonStart(service: ConnectV1Service, expectedPid: number, waitMs?: number): Promise<boolean>;
+export declare function waitForDaemonStop(service: ConnectV1Service, expectedPid: number, waitMs?: number): Promise<boolean>;
+export declare function startDaemonBackground(service: ConnectV1Service, cliPath: string, intervalSeconds?: number, options?: {
+    waitMs?: number;
+}): Promise<DaemonLaunchResult>;
+export declare function stopDaemonBackground(service: ConnectV1Service, options?: {
+    waitMs?: number;
+}): Promise<DaemonStopResult>;
+export declare function restartDaemonBackground(service: ConnectV1Service, cliPath: string, intervalSeconds?: number, options?: {
+    waitMs?: number;
+}): Promise<DaemonLaunchResult & {
+    previousPid: number | null;
+    stopMessage: string;
+}>;
+//# sourceMappingURL=daemon.d.ts.map

package/dist/v1/daemon.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDaemonScanCycle = runDaemonScanCycle;
+exports.runDaemonLoopForeground = runDaemonLoopForeground;
+exports.getDaemonHealth = getDaemonHealth;
+exports.waitForDaemonStart = waitForDaemonStart;
+exports.waitForDaemonStop = waitForDaemonStop;
+exports.startDaemonBackground = startDaemonBackground;
+exports.stopDaemonBackground = stopDaemonBackground;
+exports.restartDaemonBackground = restartDaemonBackground;
+const node_child_process_1 = require("node:child_process");
+const heartbeat_1 = require("./heartbeat");
+const DEFAULT_DAEMON_WAIT_MS = 4000;
+const DAEMON_POLL_INTERVAL_MS = 100;
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildDaemonChildEnv(service) {
+    return {
+        ...process.env,
+        FORKIT_CONNECT_STATE_DIR: service.getStateStore().getPaths().stateDir,
+    };
+}
+async function runDaemonScanCycle(service, options) {
+    try {
+        // Auto-configure runtime signal key from env var if not yet stored.
+        // This promotes pre-binding local-only events to syncable once a GAID is bound.
+        service.autoConfigureRuntimeSignalKeyFromEnv();
+        const result = options?.processScoutResults
+            ? await service.runDiscoveryCycle({ processScoutResults: options.processScoutResults })
+            : await service.runDiscoveryCycle();
+        service.recordDaemonScan(result.summary);
+        if (options?.pulseDependencies) {
+            await service.runVitalityPulseCycle(options.pulseDependencies);
+        }
+        else if (options?.processScoutResults) {
+            await service.runVitalityPulseCycle({ processScoutResults: options.processScoutResults });
+        }
+        else {
+            await service.runVitalityPulseCycle();
+        }
+        if (options?.agentProcessEntries) {
+            await service.scanAgents({ processEntries: options.agentProcessEntries, discoverySource: 'daemon_scan' });
+        }
+        service.syncEvolutionCandidates();
+        service.buildSmartRegistrationInbox();
+        const heartbeatBatch = await (0, heartbeat_1.sendAllBoundHeartbeats)(service);
+        if (heartbeatBatch.runtimeSignalQueued > 0) {
+            await service.processQueue();
+        }
+        await service.syncC2SessionsFromBackend({ suppressErrors: true });
+        await service.flushC2LifecycleEvents({ suppressErrors: true });
+        service.deliverPendingNotifications(options?.notificationSender ? { notificationSender: options.notificationSender } : undefined);
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'daemon_scan_failed';
+        service.recordDaemonError(message);
+        throw error;
+    }
+}
+async function runDaemonLoopForeground(service, options) {
+    const intervalSeconds = options?.intervalSeconds ?? service.getConfig().daemon_interval_seconds;
+    service.markDaemonStarted(process.pid);
+    let keepRunning = true;
+    let stopPersisted = false;
+    const stopLoop = () => {
+        keepRunning = false;
+    };
+    const persistStopped = (lastError) => {
+        if (stopPersisted)
+            return;
+        stopPersisted = true;
+        service.markDaemonStopped(lastError);
+    };
+    const handleTermination = () => {
+        stopLoop();
+        persistStopped(null);
+        process.exit(0);
+    };
+    process.on('SIGINT', handleTermination);
+    process.on('SIGTERM', handleTermination);
+    try {
+        while (keepRunning) {
+            if (options?.processScoutResults) {
+                if (options.pulseDependencies) {
+                    await runDaemonScanCycle(service, {
+                        processScoutResults: options.processScoutResults,
+                        pulseDependencies: options.pulseDependencies,
+                        ...(options.notificationSender ? { notificationSender: options.notificationSender } : {}),
+                        ...(options.agentProcessEntries ? { agentProcessEntries: options.agentProcessEntries } : {}),
+                    });
+                }
+                else {
+                    await runDaemonScanCycle(service, {
+                        processScoutResults: options.processScoutResults,
+                        ...(options.notificationSender ? { notificationSender: options.notificationSender } : {}),
+                        ...(options.agentProcessEntries ? { agentProcessEntries: options.agentProcessEntries } : {}),
+                    });
+                }
+            }
+            else {
+                await runDaemonScanCycle(service, options?.pulseDependencies
+                    ? {
+                        pulseDependencies: options.pulseDependencies,
+                        ...(options.notificationSender ? { notificationSender: options.notificationSender } : {}),
+                        ...(options.agentProcessEntries ? { agentProcessEntries: options.agentProcessEntries } : {}),
+                    }
+                    : options?.agentProcessEntries
+                        ? { agentProcessEntries: options.agentProcessEntries, ...(options.notificationSender ? { notificationSender: options.notificationSender } : {}) }
+                        : options?.notificationSender
+                            ? { notificationSender: options.notificationSender }
+                            : undefined);
+            }
+            if (!keepRunning)
+                break;
+            await sleep(intervalSeconds * 1000);
+        }
+        persistStopped(null);
+    }
+    catch (error) {
+        persistStopped(error instanceof Error ? error.message : 'daemon_loop_failed');
+        throw error;
+    }
+    finally {
+        process.off('SIGINT', handleTermination);
+        process.off('SIGTERM', handleTermination);
+    }
+}
+function getDaemonHealth(service) {
+    const status = service.getDaemonStatus();
+    return {
+        running: status.daemon_running,
+        pid: status.daemon_pid,
+        alive: Boolean(status.daemon_pid && isPidAlive(status.daemon_pid)),
+        lastScanAt: status.last_scan_at,
+        lastError: status.last_error,
+    };
+}
+async function waitForDaemonStart(service, expectedPid, waitMs = DEFAULT_DAEMON_WAIT_MS) {
+    const deadline = Date.now() + Math.max(waitMs, DAEMON_POLL_INTERVAL_MS);
+    while (Date.now() <= deadline) {
+        const status = service.getDaemonStatus();
+        if (status.daemon_running && status.daemon_pid === expectedPid) {
+            return true;
+        }
+        if (!isPidAlive(expectedPid)) {
+            return false;
+        }
+        await sleep(DAEMON_POLL_INTERVAL_MS);
+    }
+    return false;
+}
+async function waitForDaemonStop(service, expectedPid, waitMs = DEFAULT_DAEMON_WAIT_MS) {
+    const deadline = Date.now() + Math.max(waitMs, DAEMON_POLL_INTERVAL_MS);
+    while (Date.now() <= deadline) {
+        const status = service.getDaemonStatus();
+        if (!status.daemon_running || status.daemon_pid !== expectedPid) {
+            return true;
+        }
+        await sleep(DAEMON_POLL_INTERVAL_MS);
+    }
+    return !isPidAlive(expectedPid);
+}
+async function startDaemonBackground(service, cliPath, intervalSeconds, options) {
+    const current = getDaemonHealth(service);
+    if (current.running && current.pid && current.alive) {
+        return {
+            pid: current.pid,
+            confirmed: true,
+            message: `Forkit Connect daemon is already running. pid=${current.pid}`,
+        };
+    }
+    const args = [cliPath, 'daemon', 'run-loop'];
+    if (intervalSeconds !== undefined) {
+        args.push('--interval-seconds', String(intervalSeconds));
+    }
+    const child = (0, node_child_process_1.spawn)(process.execPath, args, {
+        detached: true,
+        stdio: 'ignore',
+        cwd: process.cwd(),
+        env: buildDaemonChildEnv(service),
+    });
+    child.unref();
+    const pid = child.pid ?? 0;
+    if (!pid) {
+        return {
+            pid: 0,
+            confirmed: false,
+            message: 'Forkit Connect could not allocate a daemon process id.',
+        };
+    }
+    const confirmed = await waitForDaemonStart(service, pid, options?.waitMs);
+    return {
+        pid,
+        confirmed,
+        message: confirmed ? null : 'Forkit Connect daemon did not report healthy startup before timeout.',
+    };
+}
+async function stopDaemonBackground(service, options) {
+    const status = service.getDaemonStatus();
+    if (!status.daemon_running || !status.daemon_pid) {
+        return {
+            pid: null,
+            stopped: true,
+            message: 'Daemon is not running.',
+        };
+    }
+    try {
+        process.kill(status.daemon_pid, 'SIGTERM');
+    }
+    catch (error) {
+        service.markDaemonStopped(error instanceof Error ? error.message : 'daemon_stop_failed');
+        return {
+            pid: status.daemon_pid,
+            stopped: false,
+            message: error instanceof Error ? error.message : 'Failed to stop daemon.',
+        };
+    }
+    const stopped = await waitForDaemonStop(service, status.daemon_pid, options?.waitMs);
+    if (!stopped) {
+        service.recordDaemonError('daemon_stop_timeout');
+        return {
+            pid: status.daemon_pid,
+            stopped: false,
+            message: 'Forkit Connect daemon did not stop before timeout.',
+        };
+    }
+    return {
+        pid: status.daemon_pid,
+        stopped: true,
+        message: `Daemon stopped. pid=${status.daemon_pid}`,
+    };
+}
+async function restartDaemonBackground(service, cliPath, intervalSeconds, options) {
+    const currentStatus = service.getDaemonStatus();
+    const stopResult = await stopDaemonBackground(service, options);
+    if (currentStatus.daemon_running && currentStatus.daemon_pid && !stopResult.stopped) {
+        return {
+            pid: currentStatus.daemon_pid,
+            confirmed: false,
+            previousPid: currentStatus.daemon_pid,
+            stopMessage: stopResult.message,
+            message: stopResult.message,
+        };
+    }
+    const launch = await startDaemonBackground(service, cliPath, intervalSeconds, options);
+    return {
+        ...launch,
+        previousPid: currentStatus.daemon_pid,
+        stopMessage: stopResult.message,
+    };
+}
+//# sourceMappingURL=daemon.js.map

package/dist/v1/discovery.d.ts

@@ -0,0 +1,61 @@
+import type { DetectedModel, DetectedRuntime, DiscoverySource } from './types';
+export interface RuntimeDiscoveryIdentityInput {
+    runtimeName: string;
+    runtimeType: string;
+    sourceEndpoint: string;
+    runtimeIdentity: string;
+}
+export interface ModelDiscoveryIdentityInput extends RuntimeDiscoveryIdentityInput {
+    modelName: string;
+    modelId: string | null;
+}
+export interface AgentDiscoveryIdentityInput {
+    agentName: string;
+    agentType: string;
+    processSignatureHash: string;
+    runtimeIdentity: string;
+}
+export interface RuntimeAttestationFingerprintInput {
+    runtimeName: string;
+    runtimeType: string;
+    runtimeProvider: string;
+    endpointHash: string;
+    runtimeIdentity: string;
+    processSignature: string | null;
+    processCommandHash: string | null;
+    processPathHash: string | null;
+    detectionMode: 'signature' | 'heuristic' | null;
+    sourceLabel: string | null;
+    matchedTerms: string[];
+    expectedPorts: number[];
+}
+export interface ModelObservationFingerprintInput {
+    runtimeName: string;
+    runtimeType: string;
+    modelName: string;
+    modelId: string | null;
+    digest: string;
+    sizeBytes: number;
+    modifiedAt: string | null;
+    metadataFingerprint: string;
+}
+export interface RuntimePassportGaidInput {
+    connectDeviceId: string;
+    runtimeName: string;
+    runtimeType: string;
+    provider: string;
+    endpointHash: string;
+}
+export declare function readEndpointPort(sourceEndpoint: string): number | null;
+export declare function buildEndpointHash(sourceEndpoint: string): string;
+export declare function buildSourceEndpointLabel(sourceEndpoint: string): string;
+export declare function buildRuntimePassportGaid(input: RuntimePassportGaidInput): string;
+export declare function buildRuntimeDiscoveryHash(input: RuntimeDiscoveryIdentityInput): string;
+export declare function buildModelDiscoveryHash(input: ModelDiscoveryIdentityInput): string;
+export declare function buildModelRegistrationKey(model: Pick<DetectedModel, 'model' | 'modelId'>, runtimeIdentity: string): string;
+export declare function buildAgentDiscoveryHash(input: AgentDiscoveryIdentityInput): string;
+export declare function buildRuntimeAttestationFingerprint(input: RuntimeAttestationFingerprintInput): string;
+export declare function buildModelObservationFingerprint(input: ModelObservationFingerprintInput): string;
+export declare function applyRuntimeDiscovery(runtime: Omit<DetectedRuntime, 'discoveryHash' | 'discoverySources'>, runtimeIdentity: string, sources?: DiscoverySource[]): DetectedRuntime;
+export declare function applyModelDiscovery(model: Omit<DetectedModel, 'discoveryHash' | 'discoverySources'>, runtimeIdentity: string, sources?: DiscoverySource[]): DetectedModel;
+//# sourceMappingURL=discovery.d.ts.map