forkit-ai-footprints 0.2.0 → 0.2.4

package/dist/cli.js

@@ -40,8 +40,8 @@ Options:
   --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
+  --anonymous-payload    Reserved for a completed one-hour monitor session
+  --consent-share        Prepare an aggregate payload; native-app consent controls Preview sync
   --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
@@ -55,9 +55,10 @@ Options:
   -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.
+  AI Footprints reads metadata only. It does not read model bytes or retain raw
+  process commands or MCP configuration values. It does not write to any passport,
+  registry, or Runtime_C2 service. The installed app may sync only the allowlisted anonymous
+  Global AI Preview aggregate after explicit v2 consent and one valid hour.
 `;
 function parseArgs(args) {
     let command = 'install';
@@ -186,12 +187,65 @@ function parseArgs(args) {
         port,
     };
 }
+const FORKIT_APP_NAME = 'Forkit AI Footprint.app';
+const FORKIT_BUNDLE_IDENTIFIER = 'dev.forkit.ai-footprints';
+const LAUNCH_SERVICES = '/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister';
+async function isForkitApp(appPath) {
+    const info = await promises_1.default.readFile(node_path_1.default.join(appPath, 'Contents', 'Info.plist'), 'utf8').catch(() => '');
+    return info.includes(FORKIT_BUNDLE_IDENTIFIER);
+}
+async function recognizedForkitApps(applicationsDirectory) {
+    const entries = await promises_1.default.readdir(applicationsDirectory, { withFileTypes: true }).catch(() => []);
+    const apps = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.endsWith('.app') || entry.name.startsWith('.'))
+            continue;
+        const candidate = node_path_1.default.join(applicationsDirectory, entry.name);
+        if (await isForkitApp(candidate))
+            apps.push(candidate);
+    }
+    return apps;
+}
+function stopRunningForkitApps(appPaths) {
+    const snapshot = (0, node_child_process_1.spawnSync)('/bin/ps', ['-axo', 'pid=,ppid=,comm='], { encoding: 'utf8', shell: false });
+    if (snapshot.status !== 0 || !snapshot.stdout)
+        return;
+    const processes = snapshot.stdout.split('\n').map((line) => {
+        const match = line.trim().match(/^(\d+)\s+(\d+)\s+(.+)$/);
+        return match ? { pid: Number(match[1]), parent: Number(match[2]), command: match[3] } : null;
+    }).filter((entry) => Boolean(entry));
+    const matching = processes.filter((entry) => appPaths.some((appPath) => entry.command.startsWith(`${appPath}/Contents/`)));
+    if (matching.length === 0)
+        return;
+    const matchingPids = new Set(matching.map((entry) => entry.pid));
+    const ordered = [...matching].sort((left, right) => Number(matchingPids.has(right.parent)) - Number(matchingPids.has(left.parent)));
+    for (const entry of ordered) {
+        try {
+            process.kill(entry.pid, 'SIGTERM');
+        }
+        catch { /* process already ended */ }
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 800);
+    for (const entry of ordered) {
+        try {
+            process.kill(entry.pid, 0);
+            process.kill(entry.pid, 'SIGKILL');
+        }
+        catch { /* process ended cleanly */ }
+    }
+}
+function unregisterApp(appPath) {
+    (0, node_child_process_1.spawnSync)(LAUNCH_SERVICES, ['-u', appPath], { stdio: 'ignore', shell: false });
+}
+function registerApp(appPath) {
+    (0, node_child_process_1.spawnSync)(LAUNCH_SERVICES, ['-f', appPath], { stdio: 'ignore', shell: false });
+}
 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');
+    const source = node_path_1.default.join(__dirname, 'bootstrap', `${FORKIT_APP_NAME}.zip`);
     try {
-        await promises_1.default.access(node_path_1.default.join(source, 'Contents', 'Info.plist'));
+        await promises_1.default.access(source);
     }
     catch {
         throw new Error('This package does not contain the macOS GUI bootstrap. Install from the packed release candidate.');
@@ -199,32 +253,55 @@ async function installPersistentMacApp(options = {}) {
     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 destination = node_path_1.default.join(applicationsDirectory, FORKIT_APP_NAME);
     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`);
+    const extraction = node_path_1.default.join(applicationsDirectory, `.Forkit AI Footprint.extracting-${process.pid}`);
+    const shouldOpen = options.open !== false && process.env.FORKIT_AI_FOOTPRINTS_NO_OPEN !== '1';
     await promises_1.default.mkdir(applicationsDirectory, { recursive: true, mode: 0o700 });
+    const recognizedApps = await recognizedForkitApps(applicationsDirectory);
+    stopRunningForkitApps(recognizedApps);
     await promises_1.default.rm(staging, { recursive: true, force: true });
-    await promises_1.default.cp(source, staging, { recursive: true, preserveTimestamps: true });
+    await promises_1.default.rm(extraction, { recursive: true, force: true });
+    await promises_1.default.mkdir(extraction, { recursive: true, mode: 0o700 });
+    const unpacked = (0, node_child_process_1.spawnSync)('/usr/bin/ditto', ['-x', '-k', source, extraction], { stdio: 'ignore', shell: false });
+    const extractedApp = node_path_1.default.join(extraction, FORKIT_APP_NAME);
+    if (unpacked.status !== 0 || !(await isForkitApp(extractedApp))) {
+        await promises_1.default.rm(extraction, { recursive: true, force: true });
+        throw new Error('The packaged macOS app has an unexpected identity.');
+    }
+    await promises_1.default.rename(extractedApp, staging);
+    await promises_1.default.rm(extraction, { recursive: true, force: 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'))
+        if (existingInfo && !existingInfo.includes(FORKIT_BUNDLE_IDENTIFIER))
             throw new Error('The destination contains a different application.');
         if (existingInfo) {
+            unregisterApp(destination);
             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 });
+        for (const duplicate of recognizedApps) {
+            if (duplicate === destination)
+                continue;
+            unregisterApp(duplicate);
+            await promises_1.default.rm(duplicate, { recursive: true, force: true });
+        }
+        if (shouldOpen)
+            registerApp(destination);
     }
     catch (error) {
         await promises_1.default.rm(staging, { recursive: true, force: true });
+        await promises_1.default.rm(extraction, { 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') {
+    if (shouldOpen) {
         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.');
@@ -278,7 +355,7 @@ async function main(args = process.argv.slice(2)) {
     }
     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`);
+        process.stdout.write(`Forkit AI Footprint is installed at ${destination}\nOpen it later from Applications or Spotlight; Terminal is no longer required.\nOn first launch, Forkit asks whether an aggregate-only measurement may be contributed to the Global AI Preview after one valid observed hour. Nothing is sent unless the person explicitly agrees.\n`);
         return 0;
     }
     if (options.command === 'serve') {
@@ -310,7 +387,7 @@ async function main(args = process.argv.slice(2)) {
             : `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');
+            process.stderr.write('Anonymous preview requires a completed one-hour GUI session with the exact payload reviewed first. Nothing was uploaded.\n');
             return 2;
         }
         return 0;
@@ -387,7 +464,7 @@ async function main(args = process.argv.slice(2)) {
     }
     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: a valid one-hour 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;
     }

package/dist/device-presence.d.ts

@@ -0,0 +1,17 @@
+export type DevicePresenceState = 'active' | 'idle' | 'locked' | 'unavailable';
+export interface DevicePresence {
+    state: DevicePresenceState;
+    idle_seconds: number | null;
+    observation_eligible: boolean;
+}
+export interface MacosDevicePresenceOptions {
+    idleThresholdSeconds?: number;
+    cacheMs?: number;
+    now?: () => number;
+    readConsole?: () => Promise<string>;
+    readHid?: () => Promise<string>;
+}
+export declare function parseMacosConsoleLocked(value: string): boolean | null;
+export declare function parseMacosIdleSeconds(value: string): number | null;
+export declare function createMacosDevicePresenceProvider(options?: MacosDevicePresenceOptions): () => Promise<DevicePresence>;
+//# sourceMappingURL=device-presence.d.ts.map

package/dist/device-presence.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMacosConsoleLocked = parseMacosConsoleLocked;
+exports.parseMacosIdleSeconds = parseMacosIdleSeconds;
+exports.createMacosDevicePresenceProvider = createMacosDevicePresenceProvider;
+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 parseMacosConsoleLocked(value) {
+    const match = /"IOConsoleLocked"\s*=\s*(Yes|No)/i.exec(value);
+    if (!match)
+        return null;
+    return match[1].toLowerCase() === 'yes';
+}
+function parseMacosIdleSeconds(value) {
+    const match = /"HIDIdleTime"\s*=\s*(\d+)/.exec(value);
+    if (!match)
+        return null;
+    const nanoseconds = Number(match[1]);
+    return Number.isFinite(nanoseconds) && nanoseconds >= 0 ? nanoseconds / 1_000_000_000 : null;
+}
+async function readIoreg(args) {
+    const { stdout } = await execFileAsync('/usr/sbin/ioreg', args, {
+        encoding: 'utf8', maxBuffer: 2_000_000, env: { ...process.env, LC_ALL: 'C', LANG: 'C' },
+    });
+    return stdout;
+}
+function createMacosDevicePresenceProvider(options = {}) {
+    const idleThresholdSeconds = Math.max(15, options.idleThresholdSeconds ?? 60);
+    const cacheMs = Math.max(500, options.cacheMs ?? 2_000);
+    const now = options.now ?? Date.now;
+    const readConsole = options.readConsole ?? (() => readIoreg(['-n', 'Root', '-d1']));
+    const readHid = options.readHid ?? (() => readIoreg(['-c', 'IOHIDSystem', '-r', '-d1']));
+    let cachedAt = 0;
+    let cached = { state: 'unavailable', idle_seconds: null, observation_eligible: false };
+    return async () => {
+        const current = now();
+        if (cachedAt > 0 && current - cachedAt < cacheMs)
+            return cached;
+        cachedAt = current;
+        try {
+            const [consoleOutput, hidOutput] = await Promise.all([readConsole(), readHid()]);
+            const locked = parseMacosConsoleLocked(consoleOutput);
+            const idleSeconds = parseMacosIdleSeconds(hidOutput);
+            if (locked === null || idleSeconds === null) {
+                cached = { state: 'unavailable', idle_seconds: idleSeconds, observation_eligible: false };
+            }
+            else if (locked) {
+                cached = { state: 'locked', idle_seconds: idleSeconds, observation_eligible: false };
+            }
+            else if (idleSeconds >= idleThresholdSeconds) {
+                cached = { state: 'idle', idle_seconds: idleSeconds, observation_eligible: false };
+            }
+            else {
+                cached = { state: 'active', idle_seconds: idleSeconds, observation_eligible: true };
+            }
+        }
+        catch {
+            cached = { state: 'unavailable', idle_seconds: null, observation_eligible: false };
+        }
+        return cached;
+    };
+}
+//# sourceMappingURL=device-presence.js.map

package/dist/global-preview.d.ts

@@ -0,0 +1,34 @@
+import type { AnonymousAiFootprintContribution } from './sharing';
+export declare const GLOBAL_PREVIEW_ENDPOINT = "https://www.forkit.dev/api/v1/ai-footprints";
+export declare const GLOBAL_PREVIEW_SYNC_INTERVAL_MS: number;
+export interface GlobalPreviewStatus {
+    state: 'disabled' | 'waiting' | 'syncing' | 'contributed' | 'unavailable';
+    last_attempt_at: string | null;
+    last_success_at: string | null;
+    last_observed_seconds: number;
+    last_error: string | null;
+}
+export interface GlobalPreviewContributorOptions {
+    stateDirectory?: string;
+    endpoint?: string;
+    fetchFn?: typeof fetch;
+    now?: () => Date;
+    minimumSyncIntervalMs?: number;
+}
+export declare class GlobalPreviewContributor {
+    private readonly stateDirectory;
+    private readonly endpoint;
+    private readonly fetchFn;
+    private readonly now;
+    private readonly minimumSyncIntervalMs;
+    private currentStatus;
+    private loaded;
+    private syncing;
+    constructor(options?: GlobalPreviewContributorOptions);
+    status(permission: 'granted' | 'declined' | 'unset'): GlobalPreviewStatus;
+    private loadReceipt;
+    private saveStatus;
+    sync(contribution: AnonymousAiFootprintContribution, permission: 'granted' | 'declined' | 'unset'): Promise<GlobalPreviewStatus>;
+    private performSync;
+}
+//# sourceMappingURL=global-preview.d.ts.map

package/dist/global-preview.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalPreviewContributor = exports.GLOBAL_PREVIEW_SYNC_INTERVAL_MS = exports.GLOBAL_PREVIEW_ENDPOINT = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const local_device_1 = require("./local-device");
+exports.GLOBAL_PREVIEW_ENDPOINT = 'https://www.forkit.dev/api/v1/ai-footprints';
+exports.GLOBAL_PREVIEW_SYNC_INTERVAL_MS = 15 * 60 * 1000;
+function base64url(value) {
+    return value.toString('base64url');
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`).join(',')}}`;
+    }
+    return JSON.stringify(value);
+}
+function previewKeyPath(stateDirectory) {
+    return node_path_1.default.join(stateDirectory, 'global-preview-key.json');
+}
+function previewReceiptPath(stateDirectory) {
+    return node_path_1.default.join(stateDirectory, 'global-preview-receipt.json');
+}
+async function writePrivateJson(target, value) {
+    await promises_1.default.mkdir(node_path_1.default.dirname(target), { recursive: true, mode: 0o700 });
+    await promises_1.default.chmod(node_path_1.default.dirname(target), 0o700);
+    const temporary = `${target}.${process.pid}.tmp`;
+    await promises_1.default.writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+    await promises_1.default.chmod(temporary, 0o600);
+    await promises_1.default.rename(temporary, target);
+    await promises_1.default.chmod(target, 0o600);
+}
+function validKeyFile(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const key = value;
+    return key.schema_version === '1.0'
+        && key.algorithm === 'Ed25519'
+        && typeof key.public_key === 'string'
+        && /^[A-Za-z0-9_-]{40,256}$/.test(key.public_key)
+        && typeof key.private_key === 'string'
+        && /^[A-Za-z0-9_-]{40,256}$/.test(key.private_key);
+}
+async function loadOrCreateKey(stateDirectory) {
+    const target = previewKeyPath(stateDirectory);
+    try {
+        const value = JSON.parse(await promises_1.default.readFile(target, 'utf8'));
+        if (validKeyFile(value))
+            return value;
+    }
+    catch {
+        // Missing or invalid local preview identity is replaced before contribution.
+    }
+    const pair = node_crypto_1.default.generateKeyPairSync('ed25519');
+    const value = {
+        schema_version: '1.0',
+        algorithm: 'Ed25519',
+        public_key: base64url(pair.publicKey.export({ type: 'spki', format: 'der' })),
+        private_key: base64url(pair.privateKey.export({ type: 'pkcs8', format: 'der' })),
+    };
+    await writePrivateJson(target, value);
+    return value;
+}
+function emptyStatus() {
+    return {
+        state: 'waiting',
+        last_attempt_at: null,
+        last_success_at: null,
+        last_observed_seconds: 0,
+        last_error: null,
+    };
+}
+function validReceipt(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const receipt = value;
+    return receipt.schema_version === '1.0'
+        && ['disabled', 'waiting', 'syncing', 'contributed', 'unavailable'].includes(String(receipt.state))
+        && (receipt.last_attempt_at === null || typeof receipt.last_attempt_at === 'string')
+        && (receipt.last_success_at === null || typeof receipt.last_success_at === 'string')
+        && Number.isSafeInteger(receipt.last_observed_seconds)
+        && Number(receipt.last_observed_seconds) >= 0
+        && (receipt.last_error === null || typeof receipt.last_error === 'string');
+}
+class GlobalPreviewContributor {
+    stateDirectory;
+    endpoint;
+    fetchFn;
+    now;
+    minimumSyncIntervalMs;
+    currentStatus = emptyStatus();
+    loaded = false;
+    syncing = null;
+    constructor(options = {}) {
+        this.stateDirectory = options.stateDirectory ?? (0, local_device_1.defaultLocalStateDirectory)();
+        this.endpoint = options.endpoint ?? exports.GLOBAL_PREVIEW_ENDPOINT;
+        this.fetchFn = options.fetchFn ?? fetch;
+        this.now = options.now ?? (() => new Date());
+        this.minimumSyncIntervalMs = options.minimumSyncIntervalMs ?? exports.GLOBAL_PREVIEW_SYNC_INTERVAL_MS;
+        const endpointUrl = new URL(this.endpoint);
+        if (endpointUrl.protocol !== 'https:' || endpointUrl.origin !== 'https://www.forkit.dev' || endpointUrl.pathname !== '/api/v1/ai-footprints') {
+            throw new Error('GLOBAL_PREVIEW_ENDPOINT_NOT_ALLOWED');
+        }
+    }
+    status(permission) {
+        return permission === 'granted' ? { ...this.currentStatus } : { ...this.currentStatus, state: 'disabled', last_error: null };
+    }
+    async loadReceipt() {
+        if (this.loaded)
+            return;
+        this.loaded = true;
+        try {
+            const value = JSON.parse(await promises_1.default.readFile(previewReceiptPath(this.stateDirectory), 'utf8'));
+            if (validReceipt(value))
+                this.currentStatus = { ...value };
+        }
+        catch {
+            this.currentStatus = emptyStatus();
+        }
+    }
+    async saveStatus() {
+        await writePrivateJson(previewReceiptPath(this.stateDirectory), {
+            schema_version: '1.0',
+            ...this.currentStatus,
+        });
+    }
+    async sync(contribution, permission) {
+        if (permission !== 'granted')
+            return this.status(permission);
+        if (this.syncing)
+            return this.syncing;
+        this.syncing = this.performSync(contribution).finally(() => { this.syncing = null; });
+        return this.syncing;
+    }
+    async performSync(contribution) {
+        await this.loadReceipt();
+        const now = this.now();
+        const lastAttempt = this.currentStatus.last_attempt_at ? Date.parse(this.currentStatus.last_attempt_at) : 0;
+        const observedSeconds = contribution.observation.valid_seconds;
+        if (lastAttempt && now.getTime() - lastAttempt < this.minimumSyncIntervalMs && observedSeconds <= this.currentStatus.last_observed_seconds + 60) {
+            return { ...this.currentStatus };
+        }
+        this.currentStatus = { ...this.currentStatus, state: 'syncing', last_attempt_at: now.toISOString(), last_error: null };
+        await this.saveStatus();
+        try {
+            const challengeResponse = await this.fetchFn(`${this.endpoint}/challenges`, {
+                method: 'POST',
+                headers: { accept: 'application/json', 'content-type': 'application/json' },
+                body: JSON.stringify({ purpose: 'preview-contribution' }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!challengeResponse.ok)
+                throw new Error(`CHALLENGE_${challengeResponse.status}`);
+            const challenge = await challengeResponse.json();
+            if (typeof challenge.challengeId !== 'string' || !/^[a-f0-9]{64}$/.test(challenge.challengeId))
+                throw new Error('CHALLENGE_INVALID');
+            const key = await loadOrCreateKey(this.stateDirectory);
+            const clientDataHash = node_crypto_1.default.createHash('sha256').update(`${challenge.challengeId}.${stableJson(contribution)}`).digest();
+            const privateKey = node_crypto_1.default.createPrivateKey({ key: Buffer.from(key.private_key, 'base64url'), type: 'pkcs8', format: 'der' });
+            const signature = node_crypto_1.default.sign(null, clientDataHash, privateKey);
+            const contributionResponse = await this.fetchFn(`${this.endpoint}/contributions`, {
+                method: 'POST',
+                headers: { accept: 'application/json', 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    consent: true,
+                    contribution,
+                    proof: {
+                        type: 'community-ed25519',
+                        challenge_id: challenge.challengeId,
+                        public_key: key.public_key,
+                        signature: base64url(signature),
+                        client_data_hash: clientDataHash.toString('hex'),
+                    },
+                }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!contributionResponse.ok)
+                throw new Error(`CONTRIBUTION_${contributionResponse.status}`);
+            const accepted = await contributionResponse.json();
+            if (accepted.accepted !== true || accepted.trustState !== 'preview')
+                throw new Error('CONTRIBUTION_NOT_ACCEPTED');
+            this.currentStatus = {
+                state: 'contributed',
+                last_attempt_at: now.toISOString(),
+                last_success_at: now.toISOString(),
+                last_observed_seconds: observedSeconds,
+                last_error: null,
+            };
+        }
+        catch (error) {
+            this.currentStatus = {
+                ...this.currentStatus,
+                state: 'unavailable',
+                last_error: error instanceof Error ? error.message.slice(0, 96) : 'GLOBAL_PREVIEW_UNAVAILABLE',
+            };
+        }
+        await this.saveStatus();
+        return { ...this.currentStatus };
+    }
+}
+exports.GlobalPreviewContributor = GlobalPreviewContributor;
+//# sourceMappingURL=global-preview.js.map

package/dist/index.d.ts

@@ -2,6 +2,8 @@ export { detectAgentProducts, listSystemProcesses } from './agents';
 export { aggregateMacosFieldEvaluationDirectory, aggregateMacosFieldEvaluations } from './aggregate';
 export { runCensus } from './census';
 export { authorizeAnonymousAiFootprintContribution, buildAnonymousAiFootprintPreview, MINIMUM_COMPARISON_SECONDS } from './sharing';
+export { GlobalPreviewContributor, GLOBAL_PREVIEW_ENDPOINT, GLOBAL_PREVIEW_SYNC_INTERVAL_MS } from './global-preview';
+export type { GlobalPreviewContributorOptions, GlobalPreviewStatus } from './global-preview';
 export { ActivityMonitor } from './monitor';
 export type * from './monitor';
 export { buildCensusShareSnapshot, renderCensusSharePage } from './share-page';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.evaluateMacosFieldTruthFile = exports.evaluateMacosFieldTruth = exports.detectMacosMajorVersion = exports.formatDoctorReport = exports.formatCensusReport = exports.scanFilesystemModels = exports.parseLoopbackEndpointList = exports.parseLoopbackEndpoint = exports.runDoctor = exports.detectMcpConfigs = exports.detectAiTools = exports.startAiFootprintsServer = exports.buildLocalInsights = exports.renderCensusSharePage = exports.buildCensusShareSnapshot = exports.ActivityMonitor = exports.MINIMUM_COMPARISON_SECONDS = exports.buildAnonymousAiFootprintPreview = exports.authorizeAnonymousAiFootprintContribution = exports.runCensus = exports.aggregateMacosFieldEvaluations = exports.aggregateMacosFieldEvaluationDirectory = exports.listSystemProcesses = exports.detectAgentProducts = void 0;
+exports.evaluateMacosFieldTruthFile = exports.evaluateMacosFieldTruth = exports.detectMacosMajorVersion = exports.formatDoctorReport = exports.formatCensusReport = exports.scanFilesystemModels = exports.parseLoopbackEndpointList = exports.parseLoopbackEndpoint = exports.runDoctor = exports.detectMcpConfigs = exports.detectAiTools = exports.startAiFootprintsServer = exports.buildLocalInsights = exports.renderCensusSharePage = exports.buildCensusShareSnapshot = exports.ActivityMonitor = exports.GLOBAL_PREVIEW_SYNC_INTERVAL_MS = exports.GLOBAL_PREVIEW_ENDPOINT = exports.GlobalPreviewContributor = exports.MINIMUM_COMPARISON_SECONDS = exports.buildAnonymousAiFootprintPreview = exports.authorizeAnonymousAiFootprintContribution = exports.runCensus = exports.aggregateMacosFieldEvaluations = exports.aggregateMacosFieldEvaluationDirectory = exports.listSystemProcesses = exports.detectAgentProducts = void 0;
 var agents_1 = require("./agents");
 Object.defineProperty(exports, "detectAgentProducts", { enumerable: true, get: function () { return agents_1.detectAgentProducts; } });
 Object.defineProperty(exports, "listSystemProcesses", { enumerable: true, get: function () { return agents_1.listSystemProcesses; } });
@@ -27,6 +27,10 @@ var sharing_1 = require("./sharing");
 Object.defineProperty(exports, "authorizeAnonymousAiFootprintContribution", { enumerable: true, get: function () { return sharing_1.authorizeAnonymousAiFootprintContribution; } });
 Object.defineProperty(exports, "buildAnonymousAiFootprintPreview", { enumerable: true, get: function () { return sharing_1.buildAnonymousAiFootprintPreview; } });
 Object.defineProperty(exports, "MINIMUM_COMPARISON_SECONDS", { enumerable: true, get: function () { return sharing_1.MINIMUM_COMPARISON_SECONDS; } });
+var global_preview_1 = require("./global-preview");
+Object.defineProperty(exports, "GlobalPreviewContributor", { enumerable: true, get: function () { return global_preview_1.GlobalPreviewContributor; } });
+Object.defineProperty(exports, "GLOBAL_PREVIEW_ENDPOINT", { enumerable: true, get: function () { return global_preview_1.GLOBAL_PREVIEW_ENDPOINT; } });
+Object.defineProperty(exports, "GLOBAL_PREVIEW_SYNC_INTERVAL_MS", { enumerable: true, get: function () { return global_preview_1.GLOBAL_PREVIEW_SYNC_INTERVAL_MS; } });
 var monitor_1 = require("./monitor");
 Object.defineProperty(exports, "ActivityMonitor", { enumerable: true, get: function () { return monitor_1.ActivityMonitor; } });
 var share_page_1 = require("./share-page");

package/dist/insights.d.ts

@@ -1,6 +1,6 @@
 import type { MonitorSnapshot } from './monitor';
 import { type UiLocale } from './localization';
-export type LocalInsightKind = 'activity-share' | 'longest-block' | 'workflow' | 'local-models-unused' | 'mostly-idle';
+export type LocalInsightKind = 'activity-share' | 'longest-block' | 'workflow' | 'local-models-unused' | 'mostly-idle' | 'hosted-local';
 export interface LocalInsight {
     kind: LocalInsightKind;
     text: string;

package/dist/insights.js

@@ -9,7 +9,9 @@ function durationLabel(value, locale) {
         return locale === 'de' ? `${seconds} Sek` : `${seconds}s`;
     if (seconds < 3600)
         return locale === 'de' ? `${Math.floor(seconds / 60)} Min ${seconds % 60} Sek` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
-    return locale === 'de' ? `${Math.floor(seconds / 3600)} Std ${Math.floor((seconds % 3600) / 60)} Min` : `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+    return locale === 'de'
+        ? `${Math.floor(seconds / 3600)} Std ${Math.floor((seconds % 3600) / 60)} Min ${seconds % 60} Sek`
+        : `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m ${seconds % 60}s`;
 }
 function longestActiveSeconds(timeline, gapToleranceMs) {
     let longest = 0;
@@ -54,22 +56,22 @@ function buildLocalInsights(monitor, footprint, minimumSeconds = MINIMUM_INSIGHT
         insights.push({ kind: 'mostly-idle', text: (0, localization_1.uiText)(locale, 'insightMostlyIdle') });
     }
     else if (activeProducts.length === 1) {
-        insights.push({ kind: 'activity-share', text: (0, localization_1.uiText)(locale, 'insightActivityProduct', { product: activeProducts[0].name, percent: activityPercent }) });
+        insights.push({ kind: 'workflow', text: (0, localization_1.uiText)(locale, 'insightFocused', { product: activeProducts[0].name }) });
     }
     else {
         insights.push({ kind: 'activity-share', text: (0, localization_1.uiText)(locale, 'insightActivityGeneric', { percent: activityPercent }) });
     }
     const longest = longestActiveSeconds(monitor.timeline, monitor.sample_interval_ms * 3);
     if (longest >= 10)
-        insights.push({ kind: 'longest-block', text: (0, localization_1.uiText)(locale, 'insightLongest', { duration: durationLabel(longest, locale) }) });
-    if (activeProducts.length > 1) {
+        insights.push({ kind: 'longest-block', text: (0, localization_1.uiText)(locale, 'insightDeepWork', { duration: durationLabel(longest, locale) }) });
+    if (footprint.confirmed_running_model_count > 0) {
+        insights.push({ kind: 'hosted-local', text: (0, localization_1.uiText)(locale, 'hostedModelsRunningInsight') });
+    }
+    else if (activeProducts.length > 1) {
         insights.push({ kind: 'workflow', text: (0, localization_1.uiText)(locale, 'insightMulti', { count: activeProducts.length }) });
     }
     else if (footprint.model_record_count > 0 && footprint.confirmed_running_model_count === 0) {
-        insights.push({ kind: 'local-models-unused', text: (0, localization_1.uiText)(locale, 'insightModelsUnused', { count: footprint.model_record_count }) });
-    }
-    else if (activeProducts.length === 1 && insights[0]?.kind !== 'activity-share') {
-        insights.push({ kind: 'workflow', text: (0, localization_1.uiText)(locale, 'insightFocused', { product: activeProducts[0].name }) });
+        insights.push({ kind: activeProducts.length ? 'hosted-local' : 'local-models-unused', text: (0, localization_1.uiText)(locale, activeProducts.length ? 'insightHostedFirst' : 'insightModelsUnused', { product: activeProducts[0]?.name ?? '', count: footprint.model_record_count }) });
     }
     return insights.slice(0, 3);
 }

package/dist/local-observation-state.d.ts

@@ -0,0 +1,43 @@
+import type { MonitorSnapshot } from './monitor';
+export interface LastStoppedSummary {
+    saved_at: string;
+    observed_seconds: number;
+    active_seconds: number;
+    activity_ratio: number | null;
+    active_tool: string | null;
+    local_models_found: number;
+    local_models_running: number;
+    share_card_data?: {
+        ratio: number | null;
+        active_tool: string | null;
+        local_models_found: number;
+        local_models_running: number;
+    };
+}
+export interface LocalObservationState {
+    schema_version: '1.0';
+    current_observation_id: number;
+    started_at: string | null;
+    observed_seconds: number;
+    active_seconds: number;
+    timeline_blocks: MonitorSnapshot['timeline'];
+    detected_systems: Array<Pick<MonitorSnapshot['products'][number], 'signature' | 'name' | 'kind' | 'state' | 'active_seconds'>>;
+    app_color_mapping: Record<string, string>;
+    latest_insights: string[];
+    last_stopped_summary: LastStoppedSummary | null;
+    user_stopped: boolean;
+    snapshot: MonitorSnapshot;
+}
+export declare function localObservationStatePath(stateDirectory?: string): string;
+export declare function loadLocalObservationState(stateDirectory?: string): Promise<LocalObservationState | null>;
+export declare function saveLocalObservationState(snapshot: MonitorSnapshot, options: {
+    latestInsights: string[];
+    localModelsFound: number;
+    localModelsRunning: number;
+    appColorMapping?: Record<string, string>;
+    userStopped?: boolean;
+    lastStoppedSummary?: LastStoppedSummary | null;
+    stateDirectory?: string;
+}): Promise<LocalObservationState>;
+export declare function clearLocalObservationState(stateDirectory?: string): Promise<void>;
+//# sourceMappingURL=local-observation-state.d.ts.map