forkit-ai-footprints 0.2.0

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/runtime-identity.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyMacosLoopbackRuntimeIdentity = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function exactBasename(value) {
+    return node_path_1.default.basename(value.trim()).toLowerCase();
+}
+/**
+ * Correlates a loopback listener with an exact executable name. Only the
+ * boolean result leaves this adapter; PID and executable path stay ephemeral.
+ */
+const verifyMacosLoopbackRuntimeIdentity = async (endpoint, expectedExecutable) => {
+    if (process.platform !== 'darwin')
+        return false;
+    let parsed;
+    try {
+        parsed = new URL(endpoint);
+    }
+    catch {
+        return false;
+    }
+    const port = Number(parsed.port || (parsed.protocol === 'https:' ? 443 : 80));
+    if (!Number.isSafeInteger(port) || port < 1 || port > 65535)
+        return false;
+    try {
+        const { stdout } = await execFileAsync('lsof', [
+            '-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-Fpc',
+        ], {
+            encoding: 'utf8',
+            maxBuffer: 1_000_000,
+            env: { ...process.env, LC_ALL: 'C', LANG: 'C' },
+        });
+        let currentPid = null;
+        const candidates = [];
+        for (const line of stdout.split('\n')) {
+            if (line.startsWith('p'))
+                currentPid = Number(line.slice(1));
+            else if (line.startsWith('c') && currentPid !== null
+                && exactBasename(line.slice(1)) === expectedExecutable.toLowerCase())
+                candidates.push(currentPid);
+        }
+        for (const pid of candidates) {
+            if (!Number.isSafeInteger(pid) || pid < 1)
+                continue;
+            const { stdout: command } = await execFileAsync('ps', ['-p', String(pid), '-o', 'comm='], {
+                encoding: 'utf8',
+                maxBuffer: 64_000,
+                env: { ...process.env, LC_ALL: 'C', LANG: 'C' },
+            });
+            if (exactBasename(command) === expectedExecutable.toLowerCase())
+                return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+};
+exports.verifyMacosLoopbackRuntimeIdentity = verifyMacosLoopbackRuntimeIdentity;
+//# sourceMappingURL=runtime-identity.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/server.d.ts

@@ -0,0 +1,21 @@
+import http from 'node:http';
+import { type LocalDeviceJournal } from './local-device';
+import { ActivityMonitor } from './monitor';
+import type { CensusReport } from './types';
+export interface AiFootprintsServerOptions {
+    hostname?: '127.0.0.1';
+    port?: number;
+    scan?: () => Promise<CensusReport>;
+    recordScan?: (generatedAt: string) => Promise<LocalDeviceJournal>;
+    monitor?: ActivityMonitor;
+    nativeToken?: string | null;
+}
+export interface AiFootprintsServer {
+    server: http.Server;
+    url: string;
+    sessionToken: string;
+    monitor: ActivityMonitor;
+    close: () => Promise<void>;
+}
+export declare function startAiFootprintsServer(options?: AiFootprintsServerOptions): Promise<AiFootprintsServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/server.js

@@ -0,0 +1,308 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAiFootprintsServer = startAiFootprintsServer;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_http_1 = __importDefault(require("node:http"));
+const census_1 = require("./census");
+const agents_1 = require("./agents");
+const share_page_1 = require("./share-page");
+const local_device_1 = require("./local-device");
+const monitor_1 = require("./monitor");
+const providers_1 = require("./providers");
+const runtime_activity_1 = require("./runtime-activity");
+const sharing_1 = require("./sharing");
+const insights_1 = require("./insights");
+const localization_1 = require("./localization");
+function securityHeaders(contentType) {
+    return {
+        'cache-control': 'no-store',
+        'content-security-policy': "default-src 'none'; img-src data:; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'self'",
+        'content-type': contentType,
+        'referrer-policy': 'no-referrer',
+        'x-content-type-options': 'nosniff',
+        'x-frame-options': 'SAMEORIGIN',
+    };
+}
+function sendText(response, status, contentType, body) {
+    response.writeHead(status, securityHeaders(contentType));
+    response.end(body);
+}
+function sendJson(response, status, value) {
+    sendText(response, status, 'application/json; charset=utf-8', JSON.stringify(value));
+}
+async function startAiFootprintsServer(options = {}) {
+    const hostname = options.hostname ?? '127.0.0.1';
+    const requestedPort = options.port ?? 47811;
+    const scan = options.scan ?? (() => (0, census_1.runCensus)());
+    const recordScan = options.recordScan ?? ((generatedAt) => (0, local_device_1.recordLocalScan)({ now: () => new Date(generatedAt) }));
+    const sessionToken = node_crypto_1.default.randomBytes(24).toString('hex');
+    const nativeToken = options.nativeToken ?? process.env.FORKIT_AI_FOOTPRINTS_NATIVE_TOKEN ?? null;
+    const runtimeProviders = (0, providers_1.createDefaultProviders)();
+    let loadedRuntimeCache = new Set();
+    let loadedRuntimeCacheAt = 0;
+    const monitor = options.monitor ?? new monitor_1.ActivityMonitor({
+        classifyProcesses: async (entries) => {
+            const now = Date.now();
+            if (now - loadedRuntimeCacheAt >= 3000) {
+                loadedRuntimeCache = await (0, runtime_activity_1.loadedRuntimeSignatures)(runtimeProviders, new Date(now).toISOString());
+                loadedRuntimeCacheAt = now;
+            }
+            return [
+                ...(0, agents_1.classifyAgentProcessTrees)(entries, process.pid),
+                ...(0, runtime_activity_1.classifyLoadedRuntimeProcesses)(entries, loadedRuntimeCache, process.pid),
+            ];
+        },
+    });
+    let currentReport = await scan();
+    let localDevice = await recordScan(currentReport.generated_at);
+    currentReport.privacy.local_state_written = true;
+    currentReport.privacy.local_state_scope = 'device-journal-only';
+    let scanning = false;
+    const streams = new Set();
+    let origin = '';
+    let closing = null;
+    let currentLocale = 'en';
+    function browserAuthorized(request) {
+        return request.headers.origin === origin
+            && request.headers['x-forkit-footprints-session'] === sessionToken;
+    }
+    function nativeAuthorized(request) {
+        return typeof nativeToken === 'string' && nativeToken.length >= 32
+            && request.headers['x-forkit-footprints-native'] === nativeToken;
+    }
+    function stopStreams() {
+        for (const stream of streams) {
+            clearInterval(stream.timer);
+            stream.response.end();
+        }
+        streams.clear();
+    }
+    function browserSnapshot(snapshot = monitor.snapshot()) {
+        return {
+            ...snapshot,
+            insights: (0, insights_1.buildLocalInsights)(snapshot, {
+                model_record_count: currentReport.summary.model_count,
+                confirmed_running_model_count: currentReport.summary.confirmed_running_model_count,
+            }, 60, currentLocale).map((insight) => insight.text),
+        };
+    }
+    const server = node_http_1.default.createServer(async (request, response) => {
+        const host = request.headers.host ?? '';
+        if (!origin || host !== new URL(origin).host) {
+            sendText(response, 421, 'text/plain; charset=utf-8', 'Invalid local host.');
+            return;
+        }
+        const requestUrl = new URL(request.url ?? '/', origin);
+        const pathname = requestUrl.pathname;
+        if (request.method === 'GET' && (pathname === '/' || pathname === '/index.html')) {
+            const requestedLocale = requestUrl.searchParams.get('lang');
+            currentLocale = requestedLocale === 'en' || requestedLocale === 'de'
+                ? requestedLocale
+                : (0, localization_1.normalizeLocale)(request.headers['accept-language']);
+            sendText(response, 200, 'text/html; charset=utf-8', (0, share_page_1.renderCensusSharePage)(currentReport, {
+                localDeviceLabel: localDevice.device_label,
+                locale: currentLocale,
+                rescan: {
+                    endpoint: '/api/scan',
+                    monitor_start_endpoint: '/api/monitor/start',
+                    monitor_stop_endpoint: '/api/monitor/stop',
+                    monitor_stream_endpoint: '/api/monitor/stream',
+                    monitor_clear_endpoint: '/api/monitor/clear',
+                    contribution_preview_endpoint: '/api/contribution/preview',
+                    locale_endpoint: '/api/ui/locale',
+                    session_token: sessionToken,
+                },
+            }));
+            return;
+        }
+        const browserControl = pathname.startsWith('/api/') && browserAuthorized(request);
+        const nativeControl = pathname.startsWith('/api/native/') && nativeAuthorized(request);
+        if (request.method === 'POST' && pathname === '/api/monitor/stream') {
+            if (!browserControl) {
+                sendJson(response, 403, { error: 'LOCAL_SESSION_REQUIRED' });
+                return;
+            }
+            response.writeHead(200, {
+                ...securityHeaders('application/x-ndjson; charset=utf-8'),
+                'content-security-policy': "default-src 'none'",
+            });
+            const send = () => response.write(`${JSON.stringify(browserSnapshot())}\n`);
+            send();
+            const timer = setInterval(send, 750);
+            timer.unref();
+            const stream = { timer, response };
+            streams.add(stream);
+            request.on('close', () => {
+                clearInterval(timer);
+                streams.delete(stream);
+            });
+            return;
+        }
+        if (request.method === 'POST' && pathname === '/api/scan') {
+            if (!browserControl) {
+                sendJson(response, 403, { error: 'LOCAL_SESSION_REQUIRED' });
+                return;
+            }
+            if (scanning) {
+                sendJson(response, 409, { error: 'SCAN_IN_PROGRESS' });
+                return;
+            }
+            scanning = true;
+            try {
+                currentReport = await scan();
+                localDevice = await recordScan(currentReport.generated_at);
+                currentReport.privacy.local_state_written = true;
+                currentReport.privacy.local_state_scope = 'device-journal-only';
+                sendJson(response, 200, (0, share_page_1.buildLocalScanView)(currentReport));
+            }
+            catch {
+                sendJson(response, 500, { error: 'LOCAL_SCAN_FAILED' });
+            }
+            finally {
+                scanning = false;
+            }
+            return;
+        }
+        const startPath = pathname === '/api/monitor/start' || pathname === '/api/native/start';
+        if (request.method === 'POST' && startPath) {
+            if (!(browserControl || nativeControl)) {
+                sendJson(response, 403, { error: 'LOCAL_SESSION_REQUIRED' });
+                return;
+            }
+            try {
+                const snapshot = await monitor.start();
+                sendJson(response, 200, nativeControl ? snapshot : browserSnapshot(snapshot));
+            }
+            catch {
+                sendJson(response, 500, { error: 'MONITOR_START_FAILED' });
+            }
+            return;
+        }
+        const stopPath = pathname === '/api/monitor/stop' || pathname === '/api/native/stop';
+        if (request.method === 'POST' && stopPath) {
+            if (!(browserControl || nativeControl)) {
+                sendJson(response, 403, { error: 'LOCAL_SESSION_REQUIRED' });
+                return;
+            }
+            const snapshot = monitor.stop();
+            sendJson(response, 200, nativeControl ? snapshot : browserSnapshot(snapshot));
+            return;
+        }
+        if (request.method === 'POST' && pathname === '/api/monitor/clear') {
+            if (!browserControl) {
+                sendJson(response, 403, { error: 'LOCAL_SESSION_REQUIRED' });
+                return;
+            }
+            sendJson(response, 200, browserSnapshot(monitor.clearHistory()));
+            return;
+        }
+        if (request.method === 'POST' && pathname === '/api/ui/locale') {
+            if (!browserControl) {
+                sendJson(response, 403, { error: 'LOCAL_SESSION_REQUIRED' });
+                return;
+            }
+            let raw = '';
+            for await (const chunk of request) {
+                raw += String(chunk);
+                if (raw.length > 128) {
+                    sendJson(response, 413, { error: 'INVALID_LOCALE' });
+                    return;
+                }
+            }
+            try {
+                const value = JSON.parse(raw);
+                if (value.locale !== 'en' && value.locale !== 'de')
+                    throw new Error('INVALID_LOCALE');
+                currentLocale = value.locale;
+                sendJson(response, 200, { locale: currentLocale });
+            }
+            catch {
+                sendJson(response, 400, { error: 'INVALID_LOCALE' });
+            }
+            return;
+        }
+        if (request.method === 'POST' && pathname === '/api/contribution/preview') {
+            if (!browserControl) {
+                sendJson(response, 403, { error: 'LOCAL_SESSION_REQUIRED' });
+                return;
+            }
+            try {
+                sendJson(response, 200, (0, sharing_1.buildAnonymousAiFootprintPreview)(currentReport, monitor.snapshot()));
+            }
+            catch (error) {
+                sendJson(response, 409, { error: error instanceof Error ? error.message : 'CONTRIBUTION_PREVIEW_UNAVAILABLE' });
+            }
+            return;
+        }
+        if (request.method === 'POST' && pathname === '/api/native/status') {
+            if (!nativeControl) {
+                sendJson(response, 403, { error: 'NATIVE_CONTROL_REQUIRED' });
+                return;
+            }
+            sendJson(response, 200, { ...monitor.snapshot(), ui_locale: currentLocale });
+            return;
+        }
+        if (request.method === 'POST' && pathname === '/api/native/quit') {
+            if (!nativeControl) {
+                sendJson(response, 403, { error: 'NATIVE_CONTROL_REQUIRED' });
+                return;
+            }
+            const summary = monitor.stop();
+            sendJson(response, 200, summary);
+            setImmediate(() => { void closeService(); });
+            return;
+        }
+        sendText(response, 404, 'text/plain; charset=utf-8', 'Not found.');
+    });
+    async function listen(port) {
+        await new Promise((resolve, reject) => {
+            const onError = (error) => {
+                server.off('listening', onListening);
+                reject(error);
+            };
+            const onListening = () => {
+                server.off('error', onError);
+                resolve();
+            };
+            server.once('error', onError);
+            server.once('listening', onListening);
+            server.listen(port, hostname);
+        });
+    }
+    try {
+        await listen(requestedPort);
+    }
+    catch (error) {
+        if (error.code !== 'EADDRINUSE' || requestedPort === 0)
+            throw error;
+        await listen(0);
+    }
+    const address = server.address();
+    origin = `http://${hostname}:${address.port}`;
+    function closeService() {
+        if (closing)
+            return closing;
+        closing = new Promise((resolve, reject) => {
+            monitor.stop();
+            stopStreams();
+            if (!server.listening) {
+                resolve();
+                return;
+            }
+            server.close((error) => error ? reject(error) : resolve());
+            server.closeIdleConnections();
+        });
+        return closing;
+    }
+    return {
+        server,
+        url: `${origin}/`,
+        sessionToken,
+        monitor,
+        close: closeService,
+    };
+}
+//# sourceMappingURL=server.js.map

package/dist/bootstrap/Forkit AI Footprint.app/Contents/Resources/app/dist/share-page.d.ts

@@ -0,0 +1,75 @@
+import type { CensusReport } from './types';
+import { type UiLocale } from './localization';
+export interface CensusShareSnapshot {
+    generated_date: string;
+    architecture_label: string;
+    model_record_count: number;
+    verified_runtime_count: number;
+    detected_agent_product_count: number;
+    detected_agent_process_count: number;
+    confirmed_running_model_count: number;
+    model_storage_bytes: number;
+    model_storage_decimal_display: string;
+    model_storage_binary_display: string;
+    model_storage_display: string;
+    model_storage_file_count: number;
+    model_storage_complete: boolean;
+    model_storage_measurement: 'recognized-logical-file-bytes';
+    external_request_count: 0;
+    product_version: string;
+    node_major: number;
+}
+export interface CensusLocalDetails {
+    agents: Array<{
+        name: string;
+        kind: string;
+        process_count: number;
+    }>;
+    runtimes: Array<{
+        name: string;
+        model_count: number;
+        loaded_model_count: number;
+    }>;
+    models: Array<{
+        name: string;
+        source: string;
+        loaded: boolean;
+    }>;
+    tools: Array<{
+        name: string;
+        status: 'configured' | 'online';
+    }>;
+    technical: {
+        runtime_probes: Array<{
+            name: string;
+            state: string;
+            error_code: string | null;
+        }>;
+        warnings: Array<{
+            code: string;
+            message: string;
+        }>;
+    };
+}
+export interface LocalScanView extends CensusShareSnapshot {
+    local_details: CensusLocalDetails;
+}
+export interface LocalRescanOptions {
+    endpoint: string;
+    monitor_start_endpoint: string;
+    monitor_stop_endpoint: string;
+    monitor_stream_endpoint: string;
+    monitor_clear_endpoint: string;
+    contribution_preview_endpoint: string;
+    locale_endpoint: string;
+    session_token: string;
+}
+export interface AiFootprintPageOptions {
+    rescan?: LocalRescanOptions;
+    localDeviceLabel?: string;
+    locale?: UiLocale;
+}
+export declare function buildCensusShareSnapshot(report: CensusReport): CensusShareSnapshot;
+export declare function buildLocalScanView(report: CensusReport): LocalScanView;
+export declare function renderCensusSharePage(report: CensusReport, options?: AiFootprintPageOptions): string;
+//# sourceMappingURL=share-page.d.ts.map