forkit-connect 0.1.4 → 0.1.6

package/dist/v1/runtime-registration.d.ts

@@ -0,0 +1,58 @@
+export type RuntimeRegistrationSubjectType = 'git_worktree' | 'git_repository' | 'service_root' | 'container_runtime' | 'other';
+export interface RuntimeToolingHint {
+    key: 'antigravity' | 'cursor' | 'vscode' | 'claude' | 'anaconda' | 'jupyter';
+    label: string;
+    detectedBy: Array<'env' | 'binary' | 'workspace'>;
+}
+export interface RuntimeProjectSnapshot {
+    cwd: string;
+    repoRoot: string;
+    repoRootName: string;
+    sourceUrl: string | null;
+    subjectType: RuntimeRegistrationSubjectType;
+    branch: string | null;
+    commit: string | null;
+    dirty: boolean;
+    relativeEntrypoint: string;
+    repoRootFingerprint: string;
+    repoRemoteFingerprint: string | null;
+    worktreeId: string;
+    detectedTooling: RuntimeToolingHint[];
+}
+export interface RuntimeRegistrationDraft {
+    name: string;
+    description: string | null;
+    sourceUrl: string | null;
+    runtimeIdentity: {
+        contractVersion: 'runtime.identity.v1';
+        subjectType: RuntimeRegistrationSubjectType;
+        subjectLabel: string;
+        repoRootFingerprint: string;
+        repoRemoteFingerprint?: string;
+        worktreeId: string;
+        entrypointRelativePath: string;
+        deploymentEnvironment: string;
+    };
+    metadata: Record<string, unknown>;
+    snapshot: RuntimeProjectSnapshot;
+}
+export interface RuntimeRegistrationOptions {
+    cwd?: string;
+    name?: string | null;
+    description?: string | null;
+    sourceUrl?: string | null;
+    entrypointRelativePath?: string | null;
+    subjectType?: RuntimeRegistrationSubjectType | null;
+    deploymentEnvironment?: string | null;
+    connectRuntimeId?: string | null;
+}
+declare function normalizeSourceUrl(raw: string | null | undefined): string | null;
+declare function sanitizeRuntimeName(value: string, maxLength?: number): string;
+export declare function buildRuntimeRegistrationDraft(snapshot: RuntimeProjectSnapshot, options?: Omit<RuntimeRegistrationOptions, 'cwd'>): RuntimeRegistrationDraft;
+export declare function inspectRuntimeProject(options?: RuntimeRegistrationOptions): RuntimeRegistrationDraft;
+export declare const __private__: {
+    normalizeSourceUrl: typeof normalizeSourceUrl;
+    sanitizeRuntimeName: typeof sanitizeRuntimeName;
+};
+export {};
+//# sourceMappingURL=runtime-registration.d.ts.map

package/dist/v1/runtime-registration.js

@@ -0,0 +1,319 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__private__ = void 0;
+exports.buildRuntimeRegistrationDraft = buildRuntimeRegistrationDraft;
+exports.inspectRuntimeProject = inspectRuntimeProject;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const DEFAULT_DEPLOYMENT_ENVIRONMENT = 'device-local';
+const SURFACE_CONTRACT_VERSION = 'passport.surface.v1';
+const RUNTIME_IDENTITY_VERSION = 'runtime.identity.v1';
+const RUNTIME_SUBJECT_TYPES = new Set([
+    'git_worktree',
+    'git_repository',
+    'service_root',
+    'container_runtime',
+    'other',
+]);
+const TOOLING_DEFINITIONS = [
+    {
+        key: 'antigravity',
+        label: 'Antigravity',
+        binaries: ['antigravity'],
+        envKeys: ['ANTIGRAVITY_HOME', 'ANTIGRAVITY_PROJECT'],
+    },
+    {
+        key: 'cursor',
+        label: 'Cursor',
+        binaries: ['cursor'],
+        workspaceMarkers: ['.cursor'],
+        envValues: ['cursor'],
+        envKeys: ['CURSOR_TRACE_ID', 'CURSOR_CONFIG_HOME'],
+    },
+    {
+        key: 'vscode',
+        label: 'VS Code',
+        binaries: ['code', 'codium'],
+        workspaceMarkers: ['.vscode'],
+        envValues: ['vscode'],
+        envKeys: ['VSCODE_GIT_IPC_HANDLE', 'VSCODE_IPC_HOOK_CLI'],
+    },
+    {
+        key: 'claude',
+        label: 'Claude',
+        binaries: ['claude'],
+        envKeys: ['CLAUDECODE', 'CLAUDE_CODE_ENTRYPOINT'],
+    },
+    {
+        key: 'anaconda',
+        label: 'Anaconda',
+        binaries: ['conda'],
+        envKeys: ['CONDA_PREFIX', 'CONDA_DEFAULT_ENV'],
+    },
+    {
+        key: 'jupyter',
+        label: 'Jupyter',
+        binaries: ['jupyter', 'jupyter-lab', 'jupyter-notebook'],
+        envKeys: ['JPY_PARENT_PID', 'JUPYTERHUB_API_TOKEN'],
+        fileSuffixes: ['.ipynb'],
+    },
+];
+function hashHex(value) {
+    return (0, node_crypto_1.createHash)('sha256').update(value, 'utf8').digest('hex');
+}
+function trimOptional(value) {
+    const normalized = String(value ?? '').trim();
+    return normalized.length ? normalized : null;
+}
+function realpathSafe(value) {
+    const resolved = node_path_1.default.resolve(value);
+    try {
+        const nativeRealpath = node_fs_1.default.realpathSync.native;
+        return typeof nativeRealpath === 'function' ? nativeRealpath(resolved) : node_fs_1.default.realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+function runGit(cwd, args) {
+    const result = (0, node_child_process_1.spawnSync)('git', args, {
+        cwd,
+        encoding: 'utf8',
+        timeout: 1500,
+    });
+    if (result.error || result.status !== 0) {
+        return null;
+    }
+    return trimOptional(result.stdout);
+}
+function commandExists(command) {
+    const runner = process.platform === 'win32' ? 'where' : 'which';
+    const result = (0, node_child_process_1.spawnSync)(runner, [command], {
+        encoding: 'utf8',
+        timeout: 1000,
+    });
+    return !result.error && result.status === 0;
+}
+function safeStatEntry(targetPath) {
+    try {
+        return node_fs_1.default.existsSync(targetPath);
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeRelativePath(value, repoRoot, cwd) {
+    const normalized = trimOptional(value);
+    if (!normalized) {
+        const relative = node_path_1.default.relative(repoRoot, cwd).replace(/\\/g, '/');
+        return relative.length ? relative : '.';
+    }
+    if (node_path_1.default.isAbsolute(normalized) || normalized.startsWith('~') || /^[A-Za-z]:[\\/]/.test(normalized)) {
+        throw new Error('Entrypoint must be relative to the runtime root.');
+    }
+    const cleaned = node_path_1.default.posix.normalize(normalized.replace(/\\/g, '/'));
+    if (cleaned.startsWith('../')) {
+        throw new Error('Entrypoint cannot point outside the runtime root.');
+    }
+    return cleaned === '' ? '.' : cleaned;
+}
+function normalizeSourceUrl(raw) {
+    const value = trimOptional(raw);
+    if (!value)
+        return null;
+    if (/^https?:\/\//i.test(value)) {
+        try {
+            const parsed = new URL(value);
+            if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+                return null;
+            }
+            parsed.hash = '';
+            return parsed.toString().replace(/\.git$/i, '');
+        }
+        catch {
+            return null;
+        }
+    }
+    const scpMatch = value.match(/^git@([^:]+):(.+)$/i);
+    if (scpMatch) {
+        return `https://${scpMatch[1]}/${String(scpMatch[2] || '').replace(/\.git$/i, '')}`;
+    }
+    const sshMatch = value.match(/^ssh:\/\/git@([^/]+)\/(.+)$/i);
+    if (sshMatch) {
+        return `https://${sshMatch[1]}/${String(sshMatch[2] || '').replace(/\.git$/i, '')}`;
+    }
+    return null;
+}
+function slugifyRuntimeLabel(value, maxLength = 80) {
+    const normalized = value
+        .trim()
+        .replace(/[\\/]+/g, '-')
+        .replace(/[^a-zA-Z0-9._-]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return (normalized || 'runtime').slice(0, maxLength);
+}
+function sanitizeRuntimeName(value, maxLength = 120) {
+    const normalized = value
+        .trim()
+        .replace(/[\\/]+/g, ' - ')
+        .replace(/[^a-zA-Z0-9 _\-().]+/g, ' ')
+        .replace(/\s{2,}/g, ' ')
+        .trim();
+    const trimmed = normalized.slice(0, maxLength).trim();
+    if (trimmed.length < 2) {
+        throw new Error('Runtime name must be at least 2 supported characters.');
+    }
+    return trimmed;
+}
+function chooseSubjectType(input, isGitRepo) {
+    const normalized = trimOptional(input);
+    if (!normalized) {
+        return isGitRepo ? 'git_worktree' : 'service_root';
+    }
+    if (!RUNTIME_SUBJECT_TYPES.has(normalized)) {
+        throw new Error(`Unsupported runtime subject type: ${normalized}`);
+    }
+    return normalized;
+}
+function detectTooling(repoRoot, cwd) {
+    const rootEntries = safeStatEntry(repoRoot) ? node_fs_1.default.readdirSync(repoRoot, { withFileTypes: true }) : [];
+    const cwdEntries = cwd !== repoRoot && safeStatEntry(cwd) ? node_fs_1.default.readdirSync(cwd, { withFileTypes: true }) : [];
+    const termProgram = String(process.env.TERM_PROGRAM || '').trim().toLowerCase();
+    return TOOLING_DEFINITIONS.flatMap((definition) => {
+        const detectedBy = new Set();
+        if (definition.envValues?.some((value) => value === termProgram)) {
+            detectedBy.add('env');
+        }
+        if (definition.envKeys?.some((key) => trimOptional(process.env[key]))) {
+            detectedBy.add('env');
+        }
+        if (definition.binaries?.some((binary) => commandExists(binary))) {
+            detectedBy.add('binary');
+        }
+        if (definition.workspaceMarkers?.some((marker) => safeStatEntry(node_path_1.default.join(repoRoot, marker)) || safeStatEntry(node_path_1.default.join(cwd, marker)))) {
+            detectedBy.add('workspace');
+        }
+        if (definition.fileSuffixes?.some((suffix) => (rootEntries.some((entry) => entry.isFile() && entry.name.endsWith(suffix))
+            || cwdEntries.some((entry) => entry.isFile() && entry.name.endsWith(suffix))))) {
+            detectedBy.add('workspace');
+        }
+        return detectedBy.size
+            ? [{
+                    key: definition.key,
+                    label: definition.label,
+                    detectedBy: Array.from(detectedBy),
+                }]
+            : [];
+    });
+}
+function buildRuntimeRegistrationDraft(snapshot, options = {}) {
+    const relativeLabel = snapshot.relativeEntrypoint === '.'
+        ? snapshot.repoRootName
+        : `${snapshot.repoRootName} (${snapshot.relativeEntrypoint.replace(/[\\/]+/g, ' - ')})`;
+    const name = sanitizeRuntimeName(options.name ? String(options.name) : relativeLabel);
+    const description = trimOptional(options.description);
+    const explicitSourceUrl = trimOptional(options.sourceUrl);
+    const normalizedExplicitSourceUrl = explicitSourceUrl ? normalizeSourceUrl(explicitSourceUrl) : null;
+    if (explicitSourceUrl && !normalizedExplicitSourceUrl) {
+        throw new Error('Source URL must be a valid http/https or git remote URL.');
+    }
+    const sourceUrl = normalizedExplicitSourceUrl ?? snapshot.sourceUrl;
+    const deploymentEnvironment = trimOptional(options.deploymentEnvironment) ?? DEFAULT_DEPLOYMENT_ENVIRONMENT;
+    const subjectLabel = name;
+    const connectRuntimeId = trimOptional(options.connectRuntimeId) ?? 'forkit_connect_cli';
+    const metadata = {
+        surface: {
+            controlPlane: 'forkit.dev',
+            contractVersion: SURFACE_CONTRACT_VERSION,
+            sourceSurface: 'connect_assisted',
+            sourceSurfaceInstance: connectRuntimeId,
+            sourceSurfaceConfidence: 'observed',
+            privacyMode: 'metadata_only',
+            attestationMode: 'self_asserted',
+        },
+        runtimeRegistration: {
+            flow: 'forkit_connect_runtime_register_v1',
+            connectRuntimeId,
+            repoRootName: snapshot.repoRootName,
+            branch: snapshot.branch,
+            commit: snapshot.commit,
+            dirty: snapshot.dirty,
+            entrypointRelativePath: snapshot.relativeEntrypoint,
+            detectedTooling: snapshot.detectedTooling,
+        },
+        projectSubjectSeed: {
+            subjectType: snapshot.subjectType,
+            subjectLabel,
+            repoRootName: snapshot.repoRootName,
+            repoRootFingerprint: snapshot.repoRootFingerprint,
+            repoRemoteFingerprint: snapshot.repoRemoteFingerprint,
+            worktreeId: snapshot.worktreeId,
+            branch: snapshot.branch,
+            commit: snapshot.commit,
+            dirty: snapshot.dirty,
+            entrypointRelativePath: snapshot.relativeEntrypoint,
+            sourceSurface: 'connect_assisted',
+            detectedTooling: snapshot.detectedTooling,
+        },
+    };
+    return {
+        name,
+        description,
+        sourceUrl,
+        runtimeIdentity: {
+            contractVersion: RUNTIME_IDENTITY_VERSION,
+            subjectType: snapshot.subjectType,
+            subjectLabel,
+            repoRootFingerprint: snapshot.repoRootFingerprint,
+            ...(snapshot.repoRemoteFingerprint ? { repoRemoteFingerprint: snapshot.repoRemoteFingerprint } : {}),
+            worktreeId: snapshot.worktreeId,
+            entrypointRelativePath: snapshot.relativeEntrypoint,
+            deploymentEnvironment,
+        },
+        metadata,
+        snapshot,
+    };
+}
+function inspectRuntimeProject(options = {}) {
+    const cwd = realpathSafe(options.cwd ?? process.cwd());
+    const repoRoot = realpathSafe(runGit(cwd, ['rev-parse', '--show-toplevel']) ?? cwd);
+    const repoRootName = node_path_1.default.basename(repoRoot) || 'runtime';
+    const branch = runGit(repoRoot, ['rev-parse', '--abbrev-ref', 'HEAD']);
+    const commit = runGit(repoRoot, ['rev-parse', 'HEAD']);
+    const dirty = Boolean(trimOptional(runGit(repoRoot, ['status', '--porcelain'])));
+    const rawRemote = runGit(repoRoot, ['config', '--get', 'remote.origin.url']);
+    const sourceUrl = normalizeSourceUrl(options.sourceUrl) ?? normalizeSourceUrl(rawRemote);
+    const subjectType = chooseSubjectType(options.subjectType, repoRoot !== cwd || Boolean(branch) || Boolean(commit));
+    const relativeEntrypoint = normalizeRelativePath(options.entrypointRelativePath, repoRoot, cwd);
+    const repoRootFingerprint = hashHex(`repo-root:${repoRoot}`);
+    const repoRemoteFingerprint = rawRemote ? hashHex(`repo-remote:${rawRemote}`) : null;
+    const worktreeSeed = `${repoRoot}|${branch || 'detached'}|${relativeEntrypoint}`;
+    const worktreeId = slugifyRuntimeLabel(`${repoRootName}-${hashHex(worktreeSeed).slice(0, 12)}`, 120);
+    const detectedTooling = detectTooling(repoRoot, cwd);
+    return buildRuntimeRegistrationDraft({
+        cwd,
+        repoRoot,
+        repoRootName,
+        sourceUrl,
+        subjectType,
+        branch,
+        commit,
+        dirty,
+        relativeEntrypoint,
+        repoRootFingerprint,
+        repoRemoteFingerprint,
+        worktreeId,
+        detectedTooling,
+    }, options);
+}
+exports.__private__ = {
+    normalizeSourceUrl,
+    sanitizeRuntimeName,
+};
+//# sourceMappingURL=runtime-registration.js.map

package/dist/v1/service.d.ts

@@ -5,7 +5,7 @@ import { type AgentProcessMetadata, type ProcessListEntry } from './process-scou
 import { LocalStateStore } from './state';
 import { type VitalityPulseDependencies } from './vitality-pulse';
 import { type MonitorPassResult } from './lifecycle-monitor';
-import type { AgentLink, AgentModelUsageLedgerSummary, AgentReviewSnapshot, AgentType, BuildDatasetRef, BuildSession, BuildSessionStatus, C2SessionControlSource, C2SessionMode, C2SessionState, C2SessionSummary, C2LifecycleEvent, C2LiteEventType, ConnectBindingState, ConnectHandoffPayload, ConnectIdentityState, ConnectPermissionsSummary, ConnectServicesSummary, ConnectState, ConnectConfig, ConnectEffectiveBindingState, ServiceEntitlements, DaemonScanSummary, DaemonStatus, DetectedAgent, DetectedModel, DeliveredNotification, EvolutionReviewSnapshot, ModelEvolutionCandidate, DiscoveryClassification, DiscoveryMode, ModelBinding, ProviderHealthStatus, NotificationCandidate, NotificationSuggestedAction, RuntimePassportStatus, RuntimeType, SmartRegistrationInbox, SmartRegistrationInboxAction, PulseStatus, ReviewSnapshot, SanitizedProcessMetadata, ShadowFinding, TrayMenuModel, TrayStatusColor, TrainingLifecycleEventType, VitalityPulseEvent, VitalityPulseSummary, PendingReview } from './types';
+import type { AgentLink, AgentModelUsageLedgerSummary, AgentReviewSnapshot, AgentType, BuildDatasetRef, BuildSession, BuildSessionStatus, C2SessionControlSource, C2SessionMode, C2SessionState, C2SessionSummary, C2LifecycleEvent, C2LiteEventType, ConnectBindingState, ConnectHandoffPayload, ConnectIdentityState, ConnectPermissionsSummary, ConnectServicesSummary, ConnectState, ConnectConfig, ConnectEffectiveBindingState, ServiceEntitlements, DaemonScanSummary, DaemonStatus, DetectedAgent, DetectedModel, DeliveredNotification, EvolutionReviewSnapshot, ModelEvolutionCandidate, DiscoveryClassification, DiscoveryMode, ModelBinding, ProviderHealthStatus, NotificationCandidate, NotificationSuggestedAction, RuntimeObserverTarget, RuntimePassportStatus, RuntimeType, SmartRegistrationInbox, SmartRegistrationInboxAction, PulseStatus, ReviewSnapshot, SanitizedProcessMetadata, ShadowFinding, TrayMenuModel, TrayStatusColor, TrainingLifecycleEventType, VitalityPulseEvent, VitalityPulseSummary, PendingReview } from './types';
 export type NotificationSender = (title: string, message: string, candidate?: NotificationCandidate) => boolean;
 export interface StatusResult {
     runtimeId: string;
@@ -326,6 +326,7 @@ export declare class ConnectV1Service {
     private buildServiceEntitlements;
     private syncServiceEntitlements;
     private syncIdentityFromLocalState;
+    private syncRuntimeIdentityMetadata;
     private createConnectIdentity;
     initializeConnectIdentity(): ConnectInitResult;
     setSessionRef(sessionRef: string | null): void;
@@ -342,6 +343,7 @@ export declare class ConnectV1Service {
     getConfig(): ConnectConfig;
     getServiceEntitlements(): ServiceEntitlements;
     private getApiClient;
+    private getApiClientWithSessionToken;
     private ensureRuntimePassportIdentity;
     private findRuntimePassportByGaid;
     private findRuntimePassportForRuntime;
@@ -452,6 +454,25 @@ export declare class ConnectV1Service {
         gaid: string;
         keyRef: string | null;
     };
+    registerRuntimeObserverTarget(input: {
+        gaid: string;
+        repoRoot: string;
+        clientName?: string | null;
+        subjectId?: string | null;
+        worktreeId?: string | null;
+    }): RuntimeObserverTarget;
+    listRuntimeObserverTargets(): RuntimeObserverTarget[];
+    hasRuntimeSignalKey(gaid: string): boolean;
+    hasStoredRuntimeSignalKey(gaid: string | null): boolean;
+    removeRuntimeObserverTarget(gaid: string): boolean;
+    updateRuntimeObserverTargetResult(input: {
+        gaid: string;
+        observedAt?: string | null;
+        emittedAt?: string | null;
+        fingerprint?: string | null;
+        summary?: string | null;
+        error?: string | null;
+    }): RuntimeObserverTarget | null;
     /**
      * After login, automatically create a runtime-signal API key for every bound
      * passport that doesn't already have one stored locally.
@@ -528,6 +549,28 @@ export declare class ConnectV1Service {
         estimatedCostCents?: number | undefined;
         currency?: string | null;
         summary?: string | null;
+        metadata?: Record<string, unknown> | null;
+        steps?: Array<Record<string, unknown>> | null;
+    }): Promise<ApiCallResult>;
+    emitRuntimeObserverCheckin(input: {
+        gaid: string;
+        apiKey?: string | null;
+        sessionId?: string | null;
+        sessionLabel?: string | null;
+        environment?: string | null;
+        region?: string | null;
+        hostLabel?: string | null;
+        runtimeLabel?: string | null;
+        runtimeMode?: 'active' | 'paused' | 'standby' | 'sleeping' | 'offline' | 'revoked' | string | null;
+        resourceAccuracy?: 'reported' | 'estimated' | 'unknown' | string | null;
+        resourceNote?: string | null;
+        cpuPercent?: number | undefined;
+        memoryMb?: number | undefined;
+        vramMb?: number | undefined;
+        promptTokens?: number | undefined;
+        completionTokens?: number | undefined;
+        executionMs?: number | undefined;
+        metadata?: Record<string, unknown> | null;
     }): Promise<ApiCallResult>;
     private findAgentByIdOrName;
     private findAgentLink;