forkit-connect 0.1.5 → 0.1.6

package/dist/resource-meter.d.ts

@@ -0,0 +1,15 @@
+export interface HardwareMetrics {
+    cpu_percent: number;
+    vram_mb: number;
+}
+export declare class ResourceMeter {
+    constructor();
+    private snapshotCpuTicks;
+    private measureCpuPercent;
+    /**
+     * Captures generalized CPU & VRAM metadata for the system bounds.
+     * Native mapping to 'nvidia-smi' exposes exact VRAM allocations.
+     */
+    captureMetrics(targetProcessPath?: string): Promise<HardwareMetrics>;
+}
+//# sourceMappingURL=resource-meter.d.ts.map

package/dist/resource-meter.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceMeter = void 0;
+const child_process_1 = require("child_process");
+const node_os_1 = __importDefault(require("node:os"));
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class ResourceMeter {
+    constructor() { }
+    snapshotCpuTicks() {
+        const cores = node_os_1.default.cpus();
+        let idle = 0;
+        let total = 0;
+        for (const core of cores) {
+            const times = core.times;
+            idle += times.idle;
+            total += times.user + times.nice + times.sys + times.idle + times.irq;
+        }
+        return { idle, total };
+    }
+    async measureCpuPercent(sampleMs = 180) {
+        const start = this.snapshotCpuTicks();
+        await new Promise((resolve) => setTimeout(resolve, sampleMs));
+        const end = this.snapshotCpuTicks();
+        const idleDelta = end.idle - start.idle;
+        const totalDelta = end.total - start.total;
+        if (totalDelta <= 0)
+            return 0;
+        const busyRatio = 1 - (idleDelta / totalDelta);
+        return Math.max(0, Math.min(100, busyRatio * 100));
+    }
+    /**
+     * Captures generalized CPU & VRAM metadata for the system bounds.
+     * Native mapping to 'nvidia-smi' exposes exact VRAM allocations.
+     */
+    async captureMetrics(targetProcessPath) {
+        let vram_mb = 0;
+        let cpu_percent = 0;
+        try {
+            cpu_percent = await this.measureCpuPercent();
+            // Attempt explicit native `nvidia-smi` read
+            const { stdout } = await execAsync('nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits');
+            if (stdout && stdout.trim()) {
+                const mems = stdout.split('\n').map(m => parseInt(m.trim())).filter(m => !isNaN(m));
+                if (mems.length > 0) {
+                    vram_mb = mems.reduce((a, b) => a + b, 0);
+                }
+            }
+        }
+        catch (e) {
+            // Graceful drop to zero if no explicit hardware bindings exist
+        }
+        return { cpu_percent, vram_mb };
+    }
+}
+exports.ResourceMeter = ResourceMeter;
+//# sourceMappingURL=resource-meter.js.map

package/dist/v1/api.d.ts

@@ -95,6 +95,7 @@ export interface ProductSummaryResponse {
         } | null;
         runtimeSignals?: {
             runtimeSignalsPerMonth?: number | null;
+            maxRuntimeSubjects?: number | null;
         } | null;
     } | null;
     entitlements?: {
@@ -105,6 +106,7 @@ export interface ProductSummaryResponse {
         maxProjects?: number | null;
         maxWorkspaces?: number | null;
         maxGovernedPassports?: number | null;
+        maxRuntimeSubjects?: number | null;
     } | null;
     usage?: {
         passports?: number | null;
@@ -114,6 +116,41 @@ export interface ProductSummaryResponse {
         runtimeSignals?: number | null;
     } | null;
 }
+export interface RuntimeResponse {
+    id?: number | string | null;
+    gaid?: string | null;
+    name?: string | null;
+    passportType?: string | null;
+    workspaceId?: string | null;
+    projectId?: string | null;
+    connectionStatus?: string | null;
+    sourceUrl?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+export interface RuntimeListResponse {
+    runtimes?: RuntimeResponse[];
+    total?: number | null;
+    runtimeLimit?: number | null;
+    usage?: {
+        runtimeSubjects?: number | null;
+    } | null;
+}
+export interface RuntimeCreateResponse {
+    runtime?: RuntimeResponse | null;
+    tier?: string | null;
+    runtimeLimit?: number | null;
+    usage?: {
+        runtimeSubjects?: number | null;
+    } | null;
+}
+export interface ApiKeyCreateResponse {
+    gaid?: string | null;
+    keyId?: string | null;
+    label?: string | null;
+    createdAt?: string | null;
+    rawKey?: string | null;
+    _warning?: string | null;
+}
 export interface WorkspaceProject {
     id?: string | null;
     workspaceId?: string | null;
@@ -294,6 +331,8 @@ export declare class ConnectApiClient {
     getPassportsMine(limit?: number): Promise<ApiCallResult>;
     getProductSummary(): Promise<ApiCallResult>;
     createPassportDraft(payload: Record<string, unknown>): Promise<ApiCallResult>;
+    getRuntimesMine(limit?: number): Promise<ApiCallResult>;
+    createRuntime(payload: Record<string, unknown>): Promise<ApiCallResult>;
     pushRuntimeSignalEvent(payload: Record<string, unknown>): Promise<ApiCallResult>;
     pushRuntimeRunLog(payload: Record<string, unknown>): Promise<ApiCallResult>;
     getDeployments(gaid: string, scope?: DeploymentScopeQuery): Promise<ApiCallResult>;
@@ -305,6 +344,7 @@ export declare class ConnectApiClient {
     resumeDeploymentSession(gaid: string, sessionId: string, payload?: DeploymentSessionControlRequest, scope?: DeploymentScopeQuery): Promise<ApiCallResult>;
     revokeDeploymentSession(gaid: string, sessionId: string, payload?: DeploymentSessionControlRequest, scope?: DeploymentScopeQuery): Promise<ApiCallResult>;
     sendDeploymentCheckin(gaid: string, payload: DeploymentCheckinRequest): Promise<ApiCallResult>;
+    sendRuntimeCheckin(gaid: string, payload: DeploymentCheckinRequest, sessionId?: string | null): Promise<ApiCallResult>;
     getProfileAccess(): Promise<ApiCallResult>;
     getWorkspaceProjects(workspaceId: string): Promise<ApiCallResult>;
     createWorkspace(payload: {
@@ -332,6 +372,7 @@ export declare class ConnectApiClient {
      * owned passport. Returns the rawKey exactly once — caller must persist it.
      */
     createPassportApiKey(gaid: string, label?: string): Promise<ApiCallResult>;
+    createRuntimeApiKey(gaid: string, label?: string): Promise<ApiCallResult>;
     private parseBody;
 }
 //# sourceMappingURL=api.d.ts.map

package/dist/v1/api.js

@@ -138,6 +138,34 @@ class ConnectApiClient {
             contract: this.parseContract(res),
         };
     }
+    async getRuntimesMine(limit = 100) {
+        const safeLimit = Math.min(Math.max(Math.trunc(Number(limit) || 100), 1), 100);
+        const url = `${this.config.baseUrl}/api/v1/runtimes/mine?limit=${safeLimit}`;
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: this.getHeaders(),
+        });
+        return {
+            ok: res.ok,
+            status: res.status,
+            body: await this.parseBody(res),
+            contract: this.parseContract(res),
+        };
+    }
+    async createRuntime(payload) {
+        const url = `${this.config.baseUrl}/api/v1/runtimes`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(payload),
+        });
+        return {
+            ok: res.ok,
+            status: res.status,
+            body: await this.parseBody(res),
+            contract: this.parseContract(res),
+        };
+    }
     async pushRuntimeSignalEvent(payload) {
         const url = `${this.config.baseUrl}/api/v1/runtime-signals/events`;
         const res = await fetch(url, {
@@ -278,6 +306,21 @@ class ConnectApiClient {
             contract: this.parseContract(res),
         };
     }
+    async sendRuntimeCheckin(gaid, payload, sessionId) {
+        const suffix = sessionId ? `/${encodeURIComponent(sessionId)}` : '';
+        const url = `${this.config.baseUrl}/api/v1/runtimes/${encodeURIComponent(gaid)}/checkins${suffix}`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify(payload),
+        });
+        return {
+            ok: res.ok,
+            status: res.status,
+            body: await this.parseBody(res),
+            contract: this.parseContract(res),
+        };
+    }
     async getProfileAccess() {
         const url = `${this.config.baseUrl}/api/profiles/access`;
         const res = await fetch(url, {
@@ -507,6 +550,20 @@ class ConnectApiClient {
             contract: this.parseContract(res),
         };
     }
+    async createRuntimeApiKey(gaid, label) {
+        const url = `${this.config.baseUrl}/api/v1/runtimes/${encodeURIComponent(gaid)}/api-keys`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: JSON.stringify({ label: label ?? 'Forkit Connect runtime' }),
+        });
+        return {
+            ok: res.ok,
+            status: res.status,
+            body: await this.parseBody(res),
+            contract: this.parseContract(res),
+        };
+    }
     async parseBody(res) {
         const contentType = res.headers.get('content-type') ?? '';
         if (contentType.includes('application/json')) {

package/dist/v1/daemon.js

@@ -10,6 +10,7 @@ exports.stopDaemonBackground = stopDaemonBackground;
 exports.restartDaemonBackground = restartDaemonBackground;
 const node_child_process_1 = require("node:child_process");
 const heartbeat_1 = require("./heartbeat");
+const runtime_observation_runner_1 = require("./runtime-observation-runner");
 const DEFAULT_DAEMON_WAIT_MS = 4000;
 const DAEMON_POLL_INTERVAL_MS = 100;
 function sleep(ms) {
@@ -61,6 +62,14 @@ async function runDaemonScanCycle(service, options) {
         }
         await service.syncC2SessionsFromBackend({ suppressErrors: true });
         await service.flushC2LifecycleEvents({ suppressErrors: true });
+        try {
+            await (0, runtime_observation_runner_1.observeRegisteredRuntimeTargets)(service, {
+                ...(options?.agentProcessEntries ? { processEntries: options.agentProcessEntries } : {}),
+            });
+        }
+        catch {
+            // Runtime journaling is additive; daemon discovery and heartbeat must continue even if observer reads fail.
+        }
         service.deliverPendingNotifications(options?.notificationSender ? { notificationSender: options.notificationSender } : undefined);
         return result;
     }

package/dist/v1/repo-discovery.d.ts

@@ -0,0 +1,42 @@
+export type RepoHostKind = 'github' | 'gitlab' | 'bitbucket' | 'azure-devops' | 'other';
+export interface GitRemote {
+    name: string;
+    fetchUrl: string | null;
+    pushUrl: string | null;
+}
+export interface RepoDetectionResult {
+    cwd: string;
+    isGitRepo: boolean;
+    rootPath: string | null;
+    relativeCwd: string | null;
+    branch: string | null;
+    headCommit: string | null;
+    remotes: GitRemote[];
+    preferredRemote: GitRemote | null;
+    sourceHost: RepoHostKind | null;
+    repoSlug: string | null;
+    dirty: boolean | null;
+}
+export interface RepoCommandResult {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+}
+export type RepoCommandRunner = (command: string, args: string[], options?: {
+    cwd?: string;
+    timeoutMs?: number;
+}) => RepoCommandResult;
+export declare function parseRemoteUrl(input: string): {
+    host: RepoHostKind;
+    slug: string | null;
+};
+export declare function classifyRepoHost(hostname: string): RepoHostKind;
+export declare function parseGitRemoteOutput(output: string): GitRemote[];
+export declare function parseGitStatusFiles(output: string): string[];
+export declare function defaultRepoCommandRunner(command: string, args: string[], options?: {
+    cwd?: string;
+    timeoutMs?: number;
+}): RepoCommandResult;
+export declare function detectRepository(cwd?: string, runner?: RepoCommandRunner): RepoDetectionResult;
+export declare function listRepositoryChangedFiles(cwd?: string, runner?: RepoCommandRunner): string[];
+//# sourceMappingURL=repo-discovery.d.ts.map

package/dist/v1/repo-discovery.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRemoteUrl = parseRemoteUrl;
+exports.classifyRepoHost = classifyRepoHost;
+exports.parseGitRemoteOutput = parseGitRemoteOutput;
+exports.parseGitStatusFiles = parseGitStatusFiles;
+exports.defaultRepoCommandRunner = defaultRepoCommandRunner;
+exports.detectRepository = detectRepository;
+exports.listRepositoryChangedFiles = listRepositoryChangedFiles;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+function trimTrailingGitSuffix(value) {
+    return value.replace(/\.git$/i, '').replace(/\/+$/, '');
+}
+function normalizeRelativeRepoPath(value) {
+    const normalized = String(value || '').trim().replace(/\\/g, '/').replace(/^\/+/, '');
+    if (!normalized || normalized === '.')
+        return null;
+    return normalized;
+}
+function normalizeRepoPath(value) {
+    return trimTrailingGitSuffix(value.replace(/\\/g, '/'));
+}
+function parseRemoteUrl(input) {
+    const raw = String(input || '').trim();
+    if (!raw) {
+        return { host: 'other', slug: null };
+    }
+    const sshMatch = raw.match(/^[^@]+@([^:]+):(.+)$/);
+    if (sshMatch) {
+        const host = classifyRepoHost(sshMatch[1] || '');
+        return {
+            host,
+            slug: normalizeRepoPath(sshMatch[2] || '') || null,
+        };
+    }
+    try {
+        const url = new URL(raw);
+        const host = classifyRepoHost(url.hostname);
+        let pathname = normalizeRepoPath(url.pathname || '');
+        pathname = pathname.replace(/^\/+/, '');
+        if (host === 'azure-devops') {
+            const parts = pathname.split('/').filter(Boolean);
+            const devopsIndex = parts.findIndex((part) => part.toLowerCase() === '_git');
+            if (devopsIndex > 0 && devopsIndex < parts.length - 1) {
+                return {
+                    host,
+                    slug: `${parts.slice(0, devopsIndex).join('/')}/${parts[devopsIndex + 1]}`,
+                };
+            }
+        }
+        return {
+            host,
+            slug: pathname || null,
+        };
+    }
+    catch {
+        return {
+            host: 'other',
+            slug: null,
+        };
+    }
+}
+function classifyRepoHost(hostname) {
+    const normalized = String(hostname || '').trim().toLowerCase().replace(/^www\./, '');
+    if (!normalized)
+        return 'other';
+    if (normalized === 'github.com')
+        return 'github';
+    if (normalized === 'gitlab.com' || normalized.endsWith('.gitlab.com'))
+        return 'gitlab';
+    if (normalized === 'bitbucket.org' || normalized.endsWith('.bitbucket.org'))
+        return 'bitbucket';
+    if (normalized === 'dev.azure.com' || normalized.endsWith('.visualstudio.com'))
+        return 'azure-devops';
+    return 'other';
+}
+function parseGitRemoteOutput(output) {
+    const byName = new Map();
+    for (const rawLine of String(output || '').split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)$/);
+        if (!match)
+            continue;
+        const name = match[1] || '';
+        const url = match[2] || '';
+        const kind = match[3] || '';
+        const current = byName.get(name) || {
+            name,
+            fetchUrl: null,
+            pushUrl: null,
+        };
+        if (kind === 'fetch')
+            current.fetchUrl = url;
+        if (kind === 'push')
+            current.pushUrl = url;
+        byName.set(name, current);
+    }
+    return [...byName.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+function parseGitStatusFiles(output) {
+    const files = [];
+    const seen = new Set();
+    for (const rawLine of String(output || '').split(/\r?\n/)) {
+        const line = rawLine.trimEnd();
+        if (!line)
+            continue;
+        const payload = line.slice(3).trim();
+        if (!payload)
+            continue;
+        const renamedTarget = payload.includes('->') ? payload.split('->').pop() || '' : payload;
+        const normalized = normalizeRelativeRepoPath(renamedTarget.trim());
+        if (!normalized || seen.has(normalized))
+            continue;
+        seen.add(normalized);
+        files.push(normalized);
+    }
+    return files;
+}
+function selectPreferredRemote(remotes) {
+    if (!remotes.length)
+        return null;
+    return remotes.find((remote) => remote.name === 'origin') || remotes[0] || null;
+}
+function defaultRepoCommandRunner(command, args, options) {
+    const result = (0, node_child_process_1.spawnSync)(command, args, {
+        cwd: options?.cwd,
+        encoding: 'utf8',
+        timeout: options?.timeoutMs ?? 4000,
+        windowsHide: true,
+    });
+    return {
+        status: result.status,
+        stdout: String(result.stdout || ''),
+        stderr: String(result.stderr || ''),
+    };
+}
+function runGit(cwd, args, runner) {
+    return runner('git', args, { cwd, timeoutMs: 4000 });
+}
+function detectRepository(cwd = process.cwd(), runner = defaultRepoCommandRunner) {
+    const normalizedCwd = node_path_1.default.resolve(cwd);
+    const rootResult = runGit(normalizedCwd, ['rev-parse', '--show-toplevel'], runner);
+    if (rootResult.status !== 0) {
+        return {
+            cwd: normalizedCwd,
+            isGitRepo: false,
+            rootPath: null,
+            relativeCwd: null,
+            branch: null,
+            headCommit: null,
+            remotes: [],
+            preferredRemote: null,
+            sourceHost: null,
+            repoSlug: null,
+            dirty: null,
+        };
+    }
+    const rootPath = String(rootResult.stdout || '').trim() || null;
+    const branchResult = rootPath
+        ? runGit(rootPath, ['branch', '--show-current'], runner)
+        : { status: 1, stdout: '', stderr: '' };
+    const headCommitResult = rootPath
+        ? runGit(rootPath, ['rev-parse', 'HEAD'], runner)
+        : { status: 1, stdout: '', stderr: '' };
+    const remoteResult = rootPath
+        ? runGit(rootPath, ['remote', '-v'], runner)
+        : { status: 1, stdout: '', stderr: '' };
+    const dirtyResult = rootPath
+        ? runGit(rootPath, ['status', '--porcelain', '--untracked-files=no'], runner)
+        : { status: 1, stdout: '', stderr: '' };
+    const remotes = parseGitRemoteOutput(remoteResult.stdout);
+    const preferredRemote = selectPreferredRemote(remotes);
+    const preferredRemoteUrl = preferredRemote?.fetchUrl || preferredRemote?.pushUrl || '';
+    const preferredRemoteInfo = parseRemoteUrl(preferredRemoteUrl);
+    return {
+        cwd: normalizedCwd,
+        isGitRepo: true,
+        rootPath,
+        relativeCwd: rootPath ? normalizeRelativeRepoPath(node_path_1.default.relative(rootPath, normalizedCwd)) : null,
+        branch: branchResult.status === 0 ? String(branchResult.stdout || '').trim() || null : null,
+        headCommit: headCommitResult.status === 0 ? String(headCommitResult.stdout || '').trim() || null : null,
+        remotes,
+        preferredRemote,
+        sourceHost: preferredRemote ? preferredRemoteInfo.host : null,
+        repoSlug: preferredRemote ? preferredRemoteInfo.slug : null,
+        dirty: dirtyResult.status === 0 ? String(dirtyResult.stdout || '').trim().length > 0 : null,
+    };
+}
+function listRepositoryChangedFiles(cwd = process.cwd(), runner = defaultRepoCommandRunner) {
+    const repo = detectRepository(cwd, runner);
+    if (!repo.isGitRepo || !repo.rootPath) {
+        return [];
+    }
+    const statusResult = runGit(repo.rootPath, ['status', '--porcelain'], runner);
+    if (statusResult.status !== 0) {
+        return [];
+    }
+    return parseGitStatusFiles(statusResult.stdout);
+}
+//# sourceMappingURL=repo-discovery.js.map

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

@@ -0,0 +1,55 @@
+import type { RepoDetectionResult } from './repo-discovery';
+export interface RuntimeActivityResourcesInput {
+    cpuPercent?: number | undefined;
+    memoryMb?: number | undefined;
+    vramMb?: number | undefined;
+}
+export interface RuntimeActivityThreadInput {
+    title: string;
+    taskId?: string | null;
+    openedAt?: string | null;
+    lastActiveAt?: string | null;
+    provider?: string | null;
+    actorLabel?: string | null;
+    workspaceHost?: string | null;
+    folderScope?: string | null;
+}
+export interface RuntimeActivityBuildInput {
+    cwd: string;
+    repo: RepoDetectionResult;
+    stableSubjectId?: string | undefined;
+    stableWorktreeId?: string | undefined;
+    changedFiles?: string[];
+    provider: string;
+    model: string;
+    serviceName: string;
+    serviceKind?: string | null;
+    status?: string | null;
+    startedAt: string;
+    endedAt?: string | null;
+    summary?: string | null;
+    clientName?: string | null;
+    commandLabel?: string | null;
+    includeServiceNameAsActor?: boolean | undefined;
+    actorLabels?: string[];
+    taskLabels?: string[];
+    activityThreads?: RuntimeActivityThreadInput[];
+    folderLabels?: string[];
+    fileLabels?: string[];
+    scopeFileLabels?: string[];
+    modelLabels?: string[];
+    promptTokens?: number | undefined;
+    completionTokens?: number | undefined;
+    cachedPromptTokens?: number | undefined;
+    reasoningTokens?: number | undefined;
+    totalTokens?: number | undefined;
+    latencyMs?: number | undefined;
+    resources?: RuntimeActivityResourcesInput;
+}
+export interface RuntimeActivityBuildResult {
+    metadata: Record<string, unknown>;
+    steps: Array<Record<string, unknown>>;
+    summary: string | null;
+}
+export declare function buildRuntimeActivityMetadata(input: RuntimeActivityBuildInput): RuntimeActivityBuildResult;
+//# sourceMappingURL=runtime-activity.d.ts.map