forkit-ai-footprints 0.2.0

package/dist/census.d.ts

@@ -0,0 +1,3 @@
+import type { CensusOptions, CensusReport } from './types';
+export declare function runCensus(options?: CensusOptions): Promise<CensusReport>;
+//# sourceMappingURL=census.d.ts.map

package/dist/census.js

@@ -0,0 +1,196 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCensus = runCensus;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const agents_1 = require("./agents");
+const filesystem_1 = require("./filesystem");
+const hash_1 = require("./hash");
+const providers_1 = require("./providers");
+const version_1 = require("./version");
+const tools_1 = require("./tools");
+const mcp_1 = require("./mcp");
+function uniqueBy(items, key) {
+    const seen = new Map();
+    for (const item of items)
+        seen.set(key(item), item);
+    return [...seen.values()];
+}
+function safeProviderFailure(name, observedAt) {
+    return {
+        runtime: {
+            runtime_id: (0, hash_1.stableId)('runtime', `provider-failure:${name}`),
+            name: name === 'ollama' || name === 'lmstudio' || name === 'filesystem'
+                ? name
+                : 'openai-compatible',
+            status: 'unavailable',
+            endpoint: null,
+            model_count: 0,
+            observed_at: observedAt,
+            error_code: 'provider_scan_failed',
+            evidence_status: 'unavailable',
+        },
+        models: [],
+        warnings: [{
+                code: 'provider_scan_failed',
+                message: `${name} could not be inspected. No raw provider error was retained.`,
+                scope: 'runtime',
+            }],
+    };
+}
+function sortRuntimes(runtimes) {
+    return [...runtimes].sort((left, right) => {
+        const name = left.name.localeCompare(right.name);
+        return name !== 0 ? name : String(left.endpoint).localeCompare(String(right.endpoint));
+    });
+}
+function sortModels(models) {
+    return [...models].sort((left, right) => {
+        const runtime = left.runtime.localeCompare(right.runtime);
+        return runtime !== 0 ? runtime : left.name.localeCompare(right.name);
+    });
+}
+function buildCensusId(generatedAt, runtimes, models, agents) {
+    const evidence = [
+        generatedAt,
+        ...runtimes.map((runtime) => runtime.runtime_id),
+        ...models.map((model) => model.model_id),
+        ...agents.map((agent) => agent.agent_id),
+    ].join('|');
+    return (0, hash_1.stableId)('census', evidence);
+}
+async function runCensus(options = {}) {
+    const generatedAt = (options.now ?? (() => new Date()))().toISOString();
+    const includeRuntimes = options.includeRuntimes !== false;
+    const includeFilesystem = options.includeFilesystem !== false;
+    const includeAgents = options.includeAgents !== false;
+    const includeTools = options.includeTools !== false;
+    const includeMcp = options.includeMcp !== false;
+    const homeDir = options.homeDir ?? node_os_1.default.homedir();
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const providers = options.providers ?? (0, providers_1.createDefaultProviders)();
+    const providerResults = includeRuntimes
+        ? await Promise.all(providers.map(async (provider) => {
+            try {
+                return await provider.scan(generatedAt);
+            }
+            catch {
+                return safeProviderFailure(provider.name, generatedAt);
+            }
+        }))
+        : [];
+    const filesystemResult = includeFilesystem
+        ? await (0, filesystem_1.scanFilesystemModels)(generatedAt, options.filesystemRoots
+            ? { roots: options.filesystemRoots }
+            : {})
+        : null;
+    const warnings = [
+        ...providerResults.flatMap((result) => result.warnings),
+        ...(filesystemResult?.warnings ?? []),
+    ];
+    let agents = [];
+    if (includeAgents) {
+        try {
+            const processes = options.processEntries ?? await (0, agents_1.listSystemProcesses)();
+            agents = (0, agents_1.detectAgentProducts)(processes);
+        }
+        catch {
+            warnings.push({
+                code: 'process_inventory_unavailable',
+                message: 'Local process inventory was unavailable. No raw process error was retained.',
+                scope: 'agent',
+            });
+        }
+    }
+    const runtimes = sortRuntimes(uniqueBy([
+        ...providerResults.map((result) => result.runtime),
+        ...(filesystemResult ? [filesystemResult.runtime] : []),
+    ], (runtime) => runtime.runtime_id));
+    const models = sortModels(uniqueBy([
+        ...providerResults.flatMap((result) => result.models),
+        ...(filesystemResult?.models ?? []),
+    ], (model) => model.model_id));
+    const processCount = agents.reduce((total, agent) => total + agent.instance_count, 0);
+    const agentCpuMeasurements = agents.flatMap((agent) => agent.resource_snapshot.cpu_percent === null
+        ? []
+        : [agent.resource_snapshot.cpu_percent]);
+    const agentMemoryMeasurements = agents.flatMap((agent) => agent.resource_snapshot.memory_percent === null
+        ? []
+        : [agent.resource_snapshot.memory_percent]);
+    const [tools, mcpConfigs] = await Promise.all([
+        includeTools ? (0, tools_1.detectAiTools)({ homeDir, env, platform, agents }) : Promise.resolve([]),
+        includeMcp ? (0, mcp_1.detectMcpConfigs)({ homeDir, cwd: node_path_1.default.resolve(cwd), env, platform }) : Promise.resolve([]),
+    ]);
+    const storage = filesystemResult?.storage ?? {
+        logical_bytes: 0,
+        recognized_file_count: 0,
+        complete: true,
+        measurement: 'recognized-logical-file-bytes',
+    };
+    const guessed = options.guess === undefined || options.guess === null
+        ? null
+        : Math.max(0, Math.floor(options.guess));
+    return {
+        schema_version: version_1.SCHEMA_VERSION,
+        product: version_1.PRODUCT_NAME,
+        product_version: version_1.PRODUCT_VERSION,
+        census_id: buildCensusId(generatedAt, runtimes, models, agents),
+        generated_at: generatedAt,
+        system: {
+            platform,
+            architecture: options.architecture ?? node_os_1.default.arch(),
+            node_major: Number(process.versions.node.split('.')[0] ?? 0),
+        },
+        privacy: {
+            mode: 'metadata-only',
+            raw_commands_retained: false,
+            model_file_contents_read: false,
+            config_values_emitted: false,
+            sensitive_content_retained: false,
+            remote_endpoints_allowed: false,
+            external_requests_made: 0,
+            backend_contacted: false,
+            account_read: false,
+            local_state_written: false,
+            local_state_scope: 'none',
+        },
+        summary: {
+            runtime_count: runtimes.length,
+            available_runtime_count: runtimes.filter((runtime) => runtime.status === 'available').length,
+            model_count: models.length,
+            agent_product_count: agents.length,
+            agent_process_count: processCount,
+            agent_cpu_percent: agentCpuMeasurements.length === 0
+                ? null
+                : Math.round(agentCpuMeasurements.reduce((total, value) => total + value, 0) * 10) / 10,
+            agent_memory_percent: agentMemoryMeasurements.length === 0
+                ? null
+                : Math.round(agentMemoryMeasurements.reduce((total, value) => total + value, 0) * 10) / 10,
+            tool_count: tools.length,
+            mcp_config_count: mcpConfigs.length,
+            confirmed_running_model_count: models.filter((model) => model.evidence_status === 'confirmed-running').length,
+            storage_bytes: storage.logical_bytes,
+            storage_file_count: storage.recognized_file_count,
+            storage_complete: storage.complete,
+            storage_measurement: storage.measurement,
+            warning_count: warnings.length,
+        },
+        runtimes,
+        models,
+        agents,
+        tools,
+        mcp_configs: mcpConfigs,
+        guess: {
+            provided: guessed,
+            discovered: models.length,
+            difference: guessed === null ? null : models.length - guessed,
+        },
+        warnings,
+    };
+}
+//# sourceMappingURL=census.js.map

package/dist/cli.d.ts

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+interface ParsedOptions {
+    command: 'install' | 'help' | 'version' | 'scan' | 'monitor' | 'doctor' | 'evaluate' | 'aggregate' | 'share-page' | 'serve';
+    json: boolean;
+    output: string | null;
+    includeRuntimes: boolean;
+    includeFilesystem: boolean;
+    includeAgents: boolean;
+    includeTools: boolean;
+    includeMcp: boolean;
+    modelDirs: string[];
+    verbose: boolean;
+    copy: boolean;
+    guess: number | null;
+    anonymousPayload: boolean;
+    shareConsent: boolean;
+    truth: string | null;
+    results: string | null;
+    port: number;
+}
+export declare function parseArgs(args: string[]): ParsedOptions;
+export declare function installPersistentMacApp(options?: {
+    applicationsDirectory?: string;
+    open?: boolean;
+}): Promise<string>;
+export declare function clipboardCommands(platform: NodeJS.Platform): Array<{
+    command: string;
+    args: string[];
+}>;
+export declare function main(args?: string[]): Promise<number>;
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,404 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.installPersistentMacApp = installPersistentMacApp;
+exports.clipboardCommands = clipboardCommands;
+exports.main = main;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_child_process_1 = require("node:child_process");
+const census_1 = require("./census");
+const doctor_1 = require("./doctor");
+const format_1 = require("./format");
+const version_1 = require("./version");
+const monitor_1 = require("./monitor");
+const evaluate_1 = require("./evaluate");
+const aggregate_1 = require("./aggregate");
+const share_page_1 = require("./share-page");
+const server_1 = require("./server");
+const local_device_1 = require("./local-device");
+const HELP = `Forkit AI Footprints
+Private, metadata-only local AI inventory.
+Apple Silicon macOS local release.
+
+Usage:
+  forkit-ai-footprints
+  forkit-ai-footprints serve [--port 47811]
+  forkit-ai-footprints monitor [--json]
+  forkit-ai-footprints scan [options]
+  forkit-ai-footprints doctor [--json]
+  forkit-ai-footprints share-page --output /path/to/local-ai-footprint.html
+  forkit-ai-footprints --version
+
+Options:
+  --json                 Print a machine-readable AI Footprint report
+  --verbose              Show detector and identity details
+  --guess <count>        Compare your estimate with discovered models
+  --copy                 Copy the rendered local result to the clipboard
+  --anonymous-payload    Reserved for a completed 10-minute monitor session
+  --consent-share        Separate consent; never enables upload in this build
+  --output <file>        Save the selected human or JSON report
+  --model-dir <path>     Inspect an explicit model directory; repeatable
+  --truth <file>         Evaluate locally against manually labelled macOS truth
+  --results <directory>  Aggregate local macOS evaluation JSON files
+  --port <number>        Local-only serve port (default: 47811)
+  --no-runtimes          Skip local runtime API discovery
+  --no-model-files       Skip filesystem model metadata discovery
+  --no-agents            Skip local process metadata discovery
+  --no-tools             Skip passive AI-tool detection
+  --no-mcp               Skip known MCP configuration counts
+  -h, --help             Show this help
+
+Privacy:
+  AI Footprints reads metadata only. It does not read model bytes, retain raw process
+  commands or MCP configuration values, authenticate to Forkit.dev, or write to
+  any passport, registry, Runtime_C2, or production service.
+`;
+function parseArgs(args) {
+    let command = 'install';
+    let json = false;
+    let output = null;
+    let includeRuntimes = true;
+    let includeFilesystem = true;
+    let includeAgents = true;
+    let includeTools = true;
+    let includeMcp = true;
+    let verbose = false;
+    let copy = false;
+    let guess = null;
+    let anonymousPayload = false;
+    let shareConsent = false;
+    let truth = null;
+    let results = null;
+    let port = 47811;
+    const modelDirs = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === 'install' || arg === 'install-app')
+            command = 'install';
+        else if (arg === 'scan' || arg === 'report')
+            command = 'scan';
+        else if (arg === 'monitor')
+            command = 'monitor';
+        else if (arg === 'doctor')
+            command = 'doctor';
+        else if (arg === 'evaluate')
+            command = 'evaluate';
+        else if (arg === 'aggregate')
+            command = 'aggregate';
+        else if (arg === 'share-page')
+            command = 'share-page';
+        else if (arg === 'serve')
+            command = 'serve';
+        else if (arg === '--version' || arg === '-V' || arg === 'version')
+            command = 'version';
+        else if (arg === '--help' || arg === '-h' || arg === 'help')
+            command = 'help';
+        else if (arg === '--json')
+            json = true;
+        else if (arg === '--verbose')
+            verbose = true;
+        else if (arg === '--copy')
+            copy = true;
+        else if (arg === '--anonymous-payload')
+            anonymousPayload = true;
+        else if (arg === '--consent-share')
+            shareConsent = true;
+        else if (arg === '--no-runtimes')
+            includeRuntimes = false;
+        else if (arg === '--no-model-files')
+            includeFilesystem = false;
+        else if (arg === '--no-agents')
+            includeAgents = false;
+        else if (arg === '--no-tools')
+            includeTools = false;
+        else if (arg === '--no-mcp')
+            includeMcp = false;
+        else if (arg === '--guess') {
+            const rawGuess = args[index + 1];
+            const parsedGuess = Number(rawGuess);
+            if (!rawGuess || !Number.isFinite(parsedGuess) || parsedGuess < 0) {
+                throw new Error('--guess requires a non-negative number.');
+            }
+            guess = Math.floor(parsedGuess);
+            index += 1;
+        }
+        else if (arg === '--port') {
+            const rawPort = args[index + 1];
+            const parsedPort = Number(rawPort);
+            if (!rawPort || !Number.isSafeInteger(parsedPort) || parsedPort < 1024 || parsedPort > 65535) {
+                throw new Error('--port requires an integer from 1024 to 65535.');
+            }
+            port = parsedPort;
+            index += 1;
+        }
+        else if (arg === '--output') {
+            output = args[index + 1] ?? null;
+            if (!output)
+                throw new Error('--output requires a file path.');
+            index += 1;
+        }
+        else if (arg === '--truth') {
+            truth = args[index + 1] ?? null;
+            if (!truth)
+                throw new Error('--truth requires a file path.');
+            index += 1;
+        }
+        else if (arg === '--results') {
+            results = args[index + 1] ?? null;
+            if (!results)
+                throw new Error('--results requires a directory path.');
+            index += 1;
+        }
+        else if (arg === '--model-dir') {
+            const directory = args[index + 1];
+            if (!directory)
+                throw new Error('--model-dir requires a directory path.');
+            modelDirs.push(directory);
+            index += 1;
+        }
+        else {
+            throw new Error(`Unknown argument: ${arg}`);
+        }
+    }
+    return {
+        command,
+        json,
+        output,
+        includeRuntimes,
+        includeFilesystem,
+        includeAgents,
+        includeTools,
+        includeMcp,
+        modelDirs,
+        verbose,
+        copy,
+        guess,
+        anonymousPayload,
+        shareConsent,
+        truth,
+        results,
+        port,
+    };
+}
+async function installPersistentMacApp(options = {}) {
+    if (process.platform !== 'darwin' || process.arch !== 'arm64')
+        throw new Error('The persistent GUI currently supports Apple Silicon macOS only.');
+    const source = node_path_1.default.join(__dirname, 'bootstrap', 'Forkit AI Footprint.app');
+    try {
+        await promises_1.default.access(node_path_1.default.join(source, 'Contents', 'Info.plist'));
+    }
+    catch {
+        throw new Error('This package does not contain the macOS GUI bootstrap. Install from the packed release candidate.');
+    }
+    const applicationsDirectory = options.applicationsDirectory
+        ?? process.env.FORKIT_AI_FOOTPRINTS_APPLICATIONS_DIR
+        ?? node_path_1.default.join(node_os_1.default.homedir(), 'Applications');
+    const destination = node_path_1.default.join(applicationsDirectory, 'Forkit AI Footprint.app');
+    const staging = node_path_1.default.join(applicationsDirectory, `.Forkit AI Footprint.installing-${process.pid}.app`);
+    const previous = node_path_1.default.join(applicationsDirectory, `.Forkit AI Footprint.previous-${process.pid}.app`);
+    await promises_1.default.mkdir(applicationsDirectory, { recursive: true, mode: 0o700 });
+    await promises_1.default.rm(staging, { recursive: true, force: true });
+    await promises_1.default.cp(source, staging, { recursive: true, preserveTimestamps: true });
+    let hadPrevious = false;
+    try {
+        const existingInfo = await promises_1.default.readFile(node_path_1.default.join(destination, 'Contents', 'Info.plist'), 'utf8').catch(() => '');
+        if (existingInfo && !existingInfo.includes('dev.forkit.ai-footprints'))
+            throw new Error('The destination contains a different application.');
+        if (existingInfo) {
+            await promises_1.default.rename(destination, previous);
+            hadPrevious = true;
+        }
+        await promises_1.default.rename(staging, destination);
+        if (hadPrevious)
+            await promises_1.default.rm(previous, { recursive: true, force: true });
+    }
+    catch (error) {
+        await promises_1.default.rm(staging, { recursive: true, force: true });
+        if (hadPrevious)
+            await promises_1.default.rename(previous, destination).catch(() => undefined);
+        throw error;
+    }
+    if (options.open !== false && process.env.FORKIT_AI_FOOTPRINTS_NO_OPEN !== '1') {
+        const launched = (0, node_child_process_1.spawnSync)('/usr/bin/open', [destination], { stdio: 'ignore', shell: false });
+        if (launched.status !== 0)
+            throw new Error('Forkit was installed, but macOS could not open it.');
+    }
+    return destination;
+}
+async function emit(output, filePath) {
+    process.stdout.write(output);
+    if (filePath)
+        await promises_1.default.writeFile(filePath, output, { encoding: 'utf8', flag: 'w' });
+}
+function clipboardCommands(platform) {
+    if (platform === 'darwin')
+        return [{ command: 'pbcopy', args: [] }];
+    if (platform === 'win32')
+        return [{ command: 'clip', args: [] }];
+    return [
+        { command: 'wl-copy', args: [] },
+        { command: 'xclip', args: ['-selection', 'clipboard'] },
+    ];
+}
+function copyToClipboard(value) {
+    for (const invocation of clipboardCommands(process.platform)) {
+        const result = (0, node_child_process_1.spawnSync)(invocation.command, invocation.args, {
+            input: value,
+            encoding: 'utf8',
+            stdio: ['pipe', 'ignore', 'ignore'],
+            shell: false,
+        });
+        if (result.status === 0)
+            return true;
+    }
+    return false;
+}
+async function main(args = process.argv.slice(2)) {
+    let options;
+    try {
+        options = parseArgs(args);
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : 'Invalid arguments'}\n\n${HELP}`);
+        return 2;
+    }
+    if (options.command === 'help') {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    if (options.command === 'version') {
+        process.stdout.write(`${version_1.PRODUCT_VERSION}\n`);
+        return 0;
+    }
+    if (options.command === 'install') {
+        const destination = await installPersistentMacApp();
+        process.stdout.write(`Forkit AI Footprint is installed at ${destination}\nOpen it later from Applications or Spotlight; Terminal is no longer required.\nYour AI activity stays on this device by default. After seeing your results, you can optionally review aggregate measurements for global comparison.\n`);
+        return 0;
+    }
+    if (options.command === 'serve') {
+        const service = await (0, server_1.startAiFootprintsServer)({ port: options.port });
+        process.stdout.write(`Forkit AI Footprints is ready at ${service.url}\nMetadata stays on this device. Press Ctrl+C to stop.\n`);
+        if (process.platform === 'darwin' && process.env.FORKIT_AI_FOOTPRINTS_NO_OPEN !== '1'
+            && process.env.FORKIT_AI_FOOTPRINTS_APP_BUNDLE !== '1') {
+            (0, node_child_process_1.spawnSync)('open', [service.url], { stdio: 'ignore', shell: false });
+        }
+        await new Promise((resolve) => {
+            const stop = () => { void service.close().finally(resolve); };
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+        });
+        return 0;
+    }
+    if (options.command === 'monitor') {
+        const monitor = new monitor_1.ActivityMonitor();
+        await monitor.start();
+        process.stderr.write('Monitoring locally until Ctrl+C. Process IDs and commands are not emitted.\n');
+        await new Promise((resolve) => {
+            const stop = () => resolve();
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+        });
+        const summary = monitor.stop();
+        const rendered = options.json
+            ? `${JSON.stringify(summary, null, 2)}\n`
+            : `Observed ${summary.observed_seconds.toFixed(1)}s · AI active ${summary.active_seconds.toFixed(1)}s · ratio ${summary.activity_ratio === null ? 'unavailable' : `${Math.round(summary.activity_ratio * 100)}%`}\n`;
+        await emit(rendered, options.output);
+        if (options.anonymousPayload) {
+            process.stderr.write('Anonymous preview requires a completed 10-minute GUI session with the exact payload reviewed first. Nothing was uploaded.\n');
+            return 2;
+        }
+        return 0;
+    }
+    if (options.command === 'doctor') {
+        const report = await (0, doctor_1.runDoctor)();
+        const rendered = options.json
+            ? `${JSON.stringify(report, null, 2)}\n`
+            : (0, format_1.formatDoctorReport)(report);
+        await emit(rendered, options.output);
+        return report.ok ? 0 : 1;
+    }
+    if (options.command === 'evaluate') {
+        if (!options.truth) {
+            process.stderr.write('evaluate requires --truth with a local labelled macOS truth file.\n');
+            return 2;
+        }
+        const evaluation = await (0, evaluate_1.evaluateMacosFieldTruthFile)(options.truth);
+        await emit(`${JSON.stringify(evaluation, null, 2)}\n`, options.output);
+        return 0;
+    }
+    if (options.command === 'aggregate') {
+        if (!options.results) {
+            process.stderr.write('aggregate requires --results with a directory of local evaluation JSON files.\n');
+            return 2;
+        }
+        const aggregate = await (0, aggregate_1.aggregateMacosFieldEvaluationDirectory)(options.results);
+        await emit(`${JSON.stringify(aggregate, null, 2)}\n`, options.output);
+        return 0;
+    }
+    if (options.command === 'share-page') {
+        if (!options.output) {
+            process.stderr.write('share-page requires --output with a local HTML file path.\n');
+            return 2;
+        }
+        const report = await (0, census_1.runCensus)({
+            includeRuntimes: options.includeRuntimes,
+            includeFilesystem: options.includeFilesystem,
+            includeAgents: options.includeAgents,
+            includeTools: options.includeTools,
+            includeMcp: options.includeMcp,
+            guess: options.guess,
+            ...(options.modelDirs.length > 0 ? { filesystemRoots: options.modelDirs } : {}),
+        });
+        if (process.env.FORKIT_AI_FOOTPRINTS_DISABLE_JOURNAL !== '1') {
+            await (0, local_device_1.recordLocalScan)({ now: () => new Date(report.generated_at) });
+            report.privacy.local_state_written = true;
+            report.privacy.local_state_scope = 'device-journal-only';
+        }
+        await promises_1.default.writeFile(options.output, (0, share_page_1.renderCensusSharePage)(report), { encoding: 'utf8', flag: 'w' });
+        process.stdout.write('Local aggregate share page written. No data was uploaded.\n');
+        return 0;
+    }
+    const report = await (0, census_1.runCensus)({
+        includeRuntimes: options.includeRuntimes,
+        includeFilesystem: options.includeFilesystem,
+        includeAgents: options.includeAgents,
+        includeTools: options.includeTools,
+        includeMcp: options.includeMcp,
+        guess: options.guess,
+        ...(options.modelDirs.length > 0 ? { filesystemRoots: options.modelDirs } : {}),
+    });
+    if (process.env.FORKIT_AI_FOOTPRINTS_DISABLE_JOURNAL !== '1') {
+        await (0, local_device_1.recordLocalScan)({ now: () => new Date(report.generated_at) });
+        report.privacy.local_state_written = true;
+        report.privacy.local_state_scope = 'device-journal-only';
+    }
+    const rendered = options.json
+        ? `${JSON.stringify(report, null, 2)}\n`
+        : (0, format_1.formatCensusReport)(report, { verbose: options.verbose });
+    await emit(rendered, options.output);
+    if (options.copy && !copyToClipboard(rendered)) {
+        process.stderr.write('Clipboard command unavailable; the result remains printable and can be copied from the terminal.\n');
+    }
+    if (options.anonymousPayload) {
+        process.stderr.write(options.shareConsent
+            ? 'Anonymous contribution was not prepared: a valid 10-minute monitor session and exact payload review are required. Nothing was uploaded.\n'
+            : 'Anonymous contribution was not prepared: separate --consent-share is required. Nothing was uploaded.\n');
+        return 2;
+    }
+    return 0;
+}
+if (require.main === module) {
+    void main().then((code) => {
+        process.exitCode = code;
+    }).catch(() => {
+        process.stderr.write('Forkit AI Footprints failed safely. No raw error details were printed.\n');
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=cli.js.map

package/dist/doctor.d.ts

@@ -0,0 +1,14 @@
+import { PRODUCT_NAME } from './version';
+export interface DoctorCheck {
+    name: string;
+    ok: boolean;
+    detail: string;
+}
+export interface DoctorReport {
+    product: typeof PRODUCT_NAME;
+    version: string;
+    ok: boolean;
+    checks: DoctorCheck[];
+}
+export declare function runDoctor(): Promise<DoctorReport>;
+//# sourceMappingURL=doctor.d.ts.map