Release: opt-in analytics + video generation

.dependency-cruiser.js

@@ -52,6 +52,13 @@ module.exports = {
       from: { path: '^src/components/' },
       to: { path: '^src/(screens|navigation)/' },
     },
+    {
+      name: 'core-not-to-pro-code',
+      severity: 'error',
+      comment: 'Video, voice, sync and tools are Pro and live in the private pro/ submodule. Core reaches them only through bootstrap/hookRegistry, slotRegistry and screenRegistry, so the open-source build compiles and runs with pro/ absent. Add a hook or slot; never import pro/ (or @offgrid/pro/*) from src/.',
+      from: { path: '^src/' },
+      to: { path: '(^pro/|^@offgrid/pro/)' },
+    },
     // ── Dead code ─────────────────────────────────────────────────────────────
     {
       name: 'no-orphans',

.gitignore

@@ -98,3 +98,7 @@ docs/wire-captures/
 
 # Scratch renders derived from scripts/e2e/fixtures (regenerable, not versioned)
 /tmp/
+
+# Generated native video runtime
+.video-build/
+native/video/*.xcframework/

App.tsx

@@ -39,13 +39,21 @@
 import { ErrorBoundary } from './src/components/ErrorBoundary';
 import { DebugLogsScreen } from './src/components/DebugLogsScreen';
 import { LoadingDots } from './src/components/LoadingDots';
+import { AnalyticsConsentPrompt } from './src/components/AnalyticsConsentPrompt';
+import {
+  startAnalytics,
+  trackScreen,
+} from './src/services/analytics/analytics';
+import { featureSnapshot } from './src/services/analytics/featureSnapshot';
 
 LogBox.ignoreAllLogs(); // Suppress all logs
 
 let stopStartupProbe: (() => void) | null = null;
-// Dev-only: mirror logger output into the in-app Debug Logs viewer. The whole block
-// is behind __DEV__, so release builds keep main's no-op logger (zero logging cost).
-if (__DEV__) {
+let stopAnalytics: (() => void) | null = null;
+// Every build mirrors logger output into the in-app Debug Logs viewer and the size-capped log
+// file, so Report a problem carries a trace from a store build too. Log lines hold metadata only,
+// never chat content (docs/ANALYTICS.md, Report a problem). The console stays dev-only (logger.ts).
+{
   const fmt = (a: unknown): string => {
     if (a instanceof Error) return `${a.name}: ${a.message}`;
     if (typeof a === 'string') return a;
@@ -68,7 +76,7 @@
   initDebugLogFile();
   // Immediately after the sink exists, so the first sample lands before anything heavy runs. The app
   // was being killed by iOS at launch with the log going silent half a second in; this says where it
-  // stops and what memory was doing when it did.
+  // stops and what memory was doing when it did. Dev builds only (the probe is a no-op elsewhere).
   stopStartupProbe = startStartupMemoryProbe();
 }
 
@@ -129,7 +137,7 @@
   });
 }
 
 function App() {
   useEffect(() => () => {
     stopStartupProbe?.();
     stopStartupProbe = null;
@@ -373,6 +381,9 @@
       logger.log('[BOOT] startup complete');
       setIsInitializing(false);
 
+      // Settings are hydrated: analytics starts only now, and only if the person opted in.
+      stopAnalytics = startAnalytics(featureSnapshot);
+
       // Reconcile downloaded Whisper models against disk at startup. presentModelIds
       // isn't persisted (the filesystem is the source of truth), so it rehydrates
       // empty — without this scan a freshly launched app shows an already-installed
@@ -406,6 +417,8 @@
     return () => {
       startupGeneration.current += 1;
       stopNetworkReconnectWatcher();
+      stopAnalytics?.();
+      stopAnalytics = null;
     };
   }, [initializeApp]);
 
@@ -447,7 +460,11 @@
         {AppRoot ? <AppRoot /> : null}
         <NavigationContainer
           ref={appNavigationRef}
-          onReady={applyPendingProRedirect}
+          onReady={() => {
+            applyPendingProRedirect();
+            trackScreen(appNavigationRef.getCurrentRoute()?.name);
+          }}
+          onStateChange={() => trackScreen(appNavigationRef.getCurrentRoute()?.name)}
           theme={{
             dark: isDark,
             colors: {
@@ -480,6 +497,7 @@
         >
           <AppNavigator />
         </NavigationContainer>
+        <AnalyticsConsentPrompt />
         {__DEV__ && showSyncStatusBar ? <DevSyncStrip /> : null}
       </SafeAreaProvider>
     </GestureHandlerRootView>

README.md

@@ -6,7 +6,9 @@
 
 ### The Swiss Army Knife of On-Device AI
 
-**Chat. Generate images. Use tools. See. Listen. All on your phone or Mac. All offline. Zero data leaves your device.**
+**Chat. Generate images. Use tools. See. Listen. All on your phone or Mac. All offline. Your chats and files never leave your device.**
+
+Anonymous usage data and crash reports only if you turn them on. See [what we share](docs/ANALYTICS.md).
 
 [![GitHub stars](https://img.shields.io/github/stars/off-grid-ai/OGAM?style=social)](https://github.com/off-grid-ai/OGAM)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
@@ -223,7 +225,7 @@ Built on the shoulders of giants:
 
 **Off Grid AI** — Your AI, your device, your data.
 
-*No cloud. No data harvesting. Just AI that works anywhere.*
+*No cloud. Your chats and files never leave your device. Just AI that works anywhere.*
 
 [Join the Community on Slack](https://join.slack.com/t/off-grid-mobile/shared_invite/zt-494gbuv5c-kj9tT7U0AS8Kq8UUO63_jw)
 

__tests__/hardening/batch9-diagnostics-debuglog.test.ts

@@ -14,9 +14,9 @@
  *    (getDeviceTier thresholds + formatBytes are already COVERED-REAL in
  *    hardware.test.ts and are NOT duplicated here.)
  *
- * 2. debugLogFile.ts — the dev file sink's size-cap/rotation logic (flush appends, checks
+ * 2. debugLogFile.ts — the file sink's size-cap/rotation logic (flush appends, checks
  *    stat, and truncates to the newest half once over MAX_BYTES), the flush-at-50-lines
- *    trigger, the disabled no-op, and __DEV__/idempotent init. No existing test covers it.
+ *    trigger, the disabled no-op, idempotent init, and the dev-only wire file. No existing test covers it.
  *    We stand up an in-memory RNFS so the REAL flush()/rotation runs end to end.
  */
 
@@ -109,7 +109,7 @@ describe('BATCH 9 — debugLogFile size-cap / rotation (real flush logic)', () =
       : '';
 
   beforeEach(() => {
-    (global as any).__DEV__ = true; // the sink is __DEV__-gated
+    (global as any).__DEV__ = true; // the wire file is __DEV__-gated
     jest.resetModules(); // fresh module-level `enabled`/`buffer` state per test
     fileSystem = require('../harness/nativeFileSystem').defaultNativeFileSystemBoundary;
     fileSystem.reset();
@@ -182,13 +182,16 @@ describe('BATCH 9 — debugLogFile size-cap / rotation (real flush logic)', () =
     expect(mod.getDebugLogPath()).toBe('/mock/documents/offgrid-debug.log');
   });
 
-  it('initDebugLogFile is a no-op outside __DEV__', async () => {
+  it('a store build writes the log for Report a problem, but never the unbounded wire file', async () => {
     (global as any).__DEV__ = false;
     jest.resetModules();
+    fileSystem = require('../harness/nativeFileSystem').defaultNativeFileSystemBoundary;
     const prodMod = require('../../src/utils/debugLogFile');
     prodMod.initDebugLogFile();
     prodMod.appendDebugLine('info', 'prod line');
+    prodMod.appendDebugLine('log', '[WIRE-STT] {"textLength":3}');
     await jest.runOnlyPendingTimersAsync();
-    expect(await readLog()).toBe('');
+    expect(await readLog()).toContain('prod line');
+    expect(await fileSystem.exists(prodMod.getWireLogPath())).toBe(false);
   });
 });

__tests__/harness/analyticsApp.ts

@@ -0,0 +1,139 @@
+/**
+ * The real App on the production navigation stack, for opt-in analytics journeys.
+ *
+ * Device boundaries only: the llama.rn engine, an in-memory disk holding one downloaded model, the
+ * RAM sensor, the OS app-state events, and the PostHog endpoint at `fetch`. A fresh install opens on
+ * Onboarding, so every journey passes Auto Setup the way a new user does.
+ */
+import { GB, installNativeBoundary, requireRTL, type NativeBoundary } from './nativeBoundary';
+import { installPostHogEndpoint, type PostHogEndpoint } from './postHogEndpoint';
+import { createDownloadedModel } from '../utils/factories';
+
+type DevGlobal = { __DEV__?: boolean };
+
+export interface AnalyticsApp {
+  boundary: NativeBoundary;
+  endpoint: PostHogEndpoint;
+  rtl: ReturnType<typeof requireRTL>;
+  view: ReturnType<ReturnType<typeof requireRTL>['render']>;
+}
+
+const originalDev = (global as DevGlobal).__DEV__;
+
+/** Put `__DEV__` back after a test that ran as a release build. */
+export function restoreBuildFlavor(): void {
+  (global as DevGlobal).__DEV__ = originalDev;
+}
+
+/**
+ * Launch the App. `release: true` runs it as a store build (`__DEV__` false), the only build that
+ * may start the analytics SDK. `relaunch: true` keeps the disk and storage of the previous launch.
+ */
+export async function launchApp(options: {
+  release: boolean;
+  relaunch?: boolean;
+  /** Installed before this version: onboarding was finished on an earlier launch. */
+  returningUser?: boolean;
+  platform?: 'ios' | 'android';
+}): Promise<AnalyticsApp> {
+  (global as DevGlobal).__DEV__ = !options.release;
+  const boundary = installNativeBoundary({
+    llama: true,
+    fs: true,
+    ram: { platform: options.platform ?? 'android', totalBytes: 12 * GB, availBytes: 8 * GB },
+  });
+  const endpoint = installPostHogEndpoint();
+  const docs = boundary.fs!.DocumentDirectoryPath;
+  const model = {
+    ...createDownloadedModel({
+    id: 'm',
+    name: 'Test Model',
+    fileName: 'small.gguf',
+    filePath: `${docs}/models/small.gguf`,
+    engine: 'llama',
+    fileSize: 500 * 1024 * 1024,
+    }),
+    // Where a Hugging Face download records it came from (a public repo).
+    origin: { repoId: 'unsloth/Qwen3-0.6B-GGUF', revision: 'main', path: 'small.gguf' },
+  };
+  // The disk a download leaves behind: the file and its record. Nothing else is pre-placed.
+  boundary.fs!.seedFile(model.filePath!, model.fileSize);
+  const storage = require('@react-native-async-storage/async-storage');
+  if (!options.relaunch) {
+    await storage.clear();
+    await storage.setItem('@local_llm/downloaded_models', JSON.stringify([model]));
+    if (options.returningUser) {
+      // What an earlier version left on disk: onboarding done, the setup tour dismissed.
+      await storage.setItem(
+        'local-llm-app-storage',
+        JSON.stringify({ state: { hasCompletedOnboarding: true, checklistDismissed: true }, version: 0 }),
+      );
+    }
+  }
+  const g = globalThis as unknown as { window?: Record<string, unknown> };
+  if (!g.window) g.window = { dispatchEvent: () => true, addEventListener: () => {}, removeEventListener: () => {} };
+  const React = require('react');
+  const rtl = requireRTL();
+  const App = require('../../App').default;
+  const view = rtl.render(React.createElement(App));
+  await rtl.waitFor(() => expect(view.queryByTestId('app-loading')).toBeNull(), { timeout: 10_000 });
+  return { boundary, endpoint, rtl, view };
+}
+
+/** A new user: Onboarding → Auto Setup (ticking the share row or not) → Skip for Now → Home. */
+export async function passOnboarding(app: AnalyticsApp, share: boolean): Promise<void> {
+  const { view, rtl } = app;
+  rtl.fireEvent.press(await view.findByTestId('onboarding-skip'));
+  const skip = await view.findByTestId('auto-setup-skip', {}, { timeout: 10_000 });
+  const row = view.getByTestId('auto-setup-share-analytics');
+  expect(row.props.accessibilityState).toEqual({ checked: false });
+  if (share) {
+    rtl.fireEvent.press(row);
+    await rtl.waitFor(() =>
+      expect(view.getByTestId('auto-setup-share-analytics').props.accessibilityState).toEqual({ checked: true }),
+    );
+  }
+  rtl.fireEvent.press(skip);
+  await view.findByTestId('home-screen');
+}
+
+export async function openNewChat(app: AnalyticsApp): Promise<void> {
+  const { view, rtl } = app;
+  rtl.fireEvent.press(view.getByTestId('browse-models-button'));
+  rtl.fireEvent.press(await view.findByTestId('text-model-row-m'));
+  await rtl.waitFor(() => expect(view.queryByTestId('text-model-row-m')).toBeNull());
+  rtl.fireEvent.press(view.getByTestId('new-chat-button'));
+  await view.findByTestId('chat-input');
+}
+
+/** Type and send a message; the model's reply (scripted at the engine leaf) renders. */
+export async function sendMessage(app: AnalyticsApp, prompt: string, reply: string): Promise<void> {
+  const { view, rtl, boundary } = app;
+  boundary.llama!.scriptCompletion({ text: reply });
+  rtl.fireEvent.changeText(view.getByTestId('chat-input'), prompt);
+  rtl.fireEvent.press(view.getByTestId('send-button'));
+  await view.findByText(reply, {}, { timeout: 10_000 });
+  await rtl.waitFor(() => expect(view.queryByTestId('stop-button')).toBeNull());
+}
+
+/** The person leaves the app: the OS moves it to the background. */
+export async function sendToBackground(app: AnalyticsApp): Promise<void> {
+  await app.rtl.act(async () => {
+    app.boundary.emitAppStateChange('background');
+  });
+}
+
+export async function bringToForeground(app: AnalyticsApp): Promise<void> {
+  await app.rtl.act(async () => {
+    app.boundary.emitAppStateChange('active');
+  });
+}
+
+/** From a chat: back to the tabs, then the Settings tab. */
+export async function openSettings(app: AnalyticsApp): Promise<void> {
+  const { view, rtl } = app;
+  const back = view.queryAllByLabelText('Back');
+  if (back.length > 0) rtl.fireEvent.press(back[0]);
+  rtl.fireEvent.press(await view.findByTestId('settings-tab'));
+  await view.findByTestId('settings-analytics');
+}

__tests__/harness/desktopVideoServer.ts

@@ -0,0 +1,95 @@
+/**
+ * Off Grid AI Desktop as the video server, at the network boundary (fetch + the RNFS download).
+ *
+ * Wire shapes are Desktop's own (desktop/src/main/model-server.ts, startGatewayVideoJob and
+ * gatewayVideoJob): POST /v1/videos answers { request_id, status, poll_url }; GET /v1/videos/{id}
+ * is the poll { request_id, status, stage, progress, result, error }; a completed result is the
+ * shared VideoGenerationResultContract plus `url: /v1/videos/{id}/content`, which the phone
+ * downloads. The model switcher is /v1/models/catalog, /installed, /active and /activate.
+ */
+import type { NativeFileSystemBoundary } from './nativeFileSystem';
+
+export const DESKTOP_VIDEO_ENDPOINT = 'http://192.168.1.62:7878'; // NOSONAR - private LAN test fixture
+export const DESKTOP_VIDEO_MODEL = { id: 'wan2.1-1.3b', name: 'Wan 2.1 1.3B' };
+
+export interface DesktopVideoJobs {
+  /** Every video submission Desktop received: the JSON body the phone sent. */
+  submissions: Array<Record<string, unknown>>;
+  restore: () => void;
+}
+
+export function serveDesktopVideoJobs(fs: NativeFileSystemBoundary): DesktopVideoJobs {
+  const original = globalThis.fetch;
+  const jobs = new Map<string, { body: Record<string, unknown>; polls: number }>();
+  let activeVideo: string | null = null;
+  const state: DesktopVideoJobs = {
+    submissions: [],
+    restore: () => {
+      globalThis.fetch = original;
+    },
+  };
+  const json = (body: unknown, status = 200) =>
+    new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json' } });
+
+  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const href = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
+    const url = new URL(href);
+    if (url.origin !== DESKTOP_VIDEO_ENDPOINT) return original(input, init);
+    const method = (init?.method ?? 'GET').toUpperCase();
+    const route = `${method} ${url.pathname}`;
+    if (route === 'GET /v1/models') return json({ object: 'list', data: [] });
+    if (route === 'GET /v1/models/catalog') {
+      return json({
+        kinds: ['text', 'vision', 'image', 'video', 'speech', 'transcription'],
+        models: [{ ...DESKTOP_VIDEO_MODEL, kind: 'video', org: 'Wan-AI', tags: [], files: [] }],
+      });
+    }
+    if (route === 'GET /v1/models/installed') return json({ installed: [DESKTOP_VIDEO_MODEL.id] });
+    if (route === 'GET /v1/models/active') {
+      return json({ text: null, image: null, video: activeVideo, speech: null, transcription: null });
+    }
+    if (route === 'POST /v1/models/activate') {
+      const body = JSON.parse(String(init?.body ?? '{}')) as { id?: string; kind?: string };
+      const known = body.kind === 'video' && body.id === DESKTOP_VIDEO_MODEL.id;
+      if (known) activeVideo = DESKTOP_VIDEO_MODEL.id;
+      return json({ success: known });
+    }
+    if (route === 'POST /v1/videos') {
+      const body = JSON.parse(String(init?.body ?? '{}')) as Record<string, unknown>;
+      state.submissions.push(body);
+      const id = String(body.client_job_id);
+      jobs.set(id, { body, polls: 0 });
+      return json({ request_id: id, object: 'request', kind: 'video', status: 'queued', poll_url: `/v1/videos/${id}` }, 202);
+    }
+    const poll = url.pathname.match(/^\/v1\/videos\/([^/]+)$/);
+    if (poll && method === 'GET') {
+      const id = decodeURIComponent(poll[1]);
+      const job = jobs.get(id);
+      if (!job) return json({ error: { message: 'Video job was not found.', type: 'not_found' } }, 404);
+      job.polls += 1;
+      const base = { request_id: id, poll_url: `/v1/videos/${id}` };
+      if (job.polls === 1) {
+        return json({ ...base, status: 'running', stage: 'generating', progress: { step: 1, total: 4 } });
+      }
+      const contentUrl = `${DESKTOP_VIDEO_ENDPOINT}/v1/videos/${id}/content`;
+      fs.serveRemoteFile(contentUrl, { body: 'mp4-bytes' });
+      // Desktop returns its job output without the local path (VideoGenerationOutputContract).
+      const { prompt, negativePrompt, width, height, frames, fps, steps, guidance, seed } = job.body;
+      return json({
+        ...base,
+        status: 'completed',
+        stage: 'encoding',
+        result: {
+          prompt, negativePrompt, width, height, frames, fps, steps, guidance, seed,
+          model: DESKTOP_VIDEO_MODEL.id,
+          durationSeconds: Number(frames) / Number(fps),
+          syncId: `desktop-video-${id}`,
+          durationMs: 4200,
+          url: `/v1/videos/${id}/content`,
+        },
+      });
+    }
+    return json({ error: { message: 'Unknown endpoint', type: 'not_found' } }, 404);
+  }) as typeof globalThis.fetch;
+  return state;
+}